Supongamos que queremos cambiar una matriz como se hace en el juego 2048 : si tenemos dos elementos consecutivos iguales en la matriz, fusionarlos en el doble del elemento de valor. Shift debe devolver una nueva matriz, donde cada par de elementos iguales consecutivos se reemplaza con su suma, y los pares no deben cruzarse. El cambio se realiza solo una vez, por lo que no necesitamos fusionar los valores resultantes nuevamente. Tenga en cuenta que si tenemos 3 elementos iguales consecutivos, tenemos que sumar los que están más a la derecha, por lo que, por ejemplo, [2, 2, 2]
debería convertirse [2, 4]
, no [4, 2]
.
La tarea es escribir la función más corta que toma una matriz y devuelve una matriz desplazada.
Puede suponer que todos los enteros serán estrictamente positivos.
Ejemplos:
[] -> []
[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]
También estoy muy interesado en la solución usando reduce :)
fuente
Respuestas:
Jalea ,
10 98 bytesTryItOnline o ejecuta todos los casos de prueba
¿Cómo?
fuente
Haskell,
475750 bytesUsos
reduce
(ofold
como se le llama en Haskell, aquí un pliegue derechofoldr
). Ejemplo de uso:map abs.foldr(#)[] $ [2,2,2,4,4,8]
->[2,4,8,8]
.Editar: +10 bytes para que funcione también para matrices sin clasificar. Los números combinados se insertan como valores negativos para evitar una segunda fusión. Se corrigen por una final
map abs
.fuente
Brain-Flak ,
15896Pruébalo en línea!
Explicación:
1 Invierta la lista (mover todo a la otra pila, pero eso no importa)
2 Siga los pasos 3-6 hasta que no quede nada en esta pila:
3 Duplicar los dos elementos superiores (2 3 -> 2 3 2 3)
4 Pon un 1 en la parte superior si los dos primeros son iguales, un 0 en caso contrario (de la wiki)
5 Si los dos primeros eran iguales (distintos de cero en el superior) agregue los dos siguientes y presione el resultado
6 Mueva el elemento superior a la otra pila
7 Cambie a la otra pila e imprima implícitamente
fuente
PHP, 116 bytes
o
-4 Bytes si la salida puede ser una matriz en
print_r
lugar de 'json_encode`176 bytes para resolver esto con una expresión regular
fuente
for($i=count($a=$argv);--$i;)$b[]=($a[$i]==$a[$i-1])?2*$a[$i--]:$a[$i];print_r(array_reverse($b));
misma idea pero más corta[]
que necesito$r=[];
Gracias por su ayudaGNU sed,
41 3837Incluye +1 para -r
-3 Gracias a Digital Trauma
-1 Gracias a seshoumara
La entrada y la salida son cadenas separadas por espacios en unario ( según este consenso ).
Pruébalo en línea!
fuente
y,!, ,
para guardar 1 byte.Retina , 32
r
en la línea 3 activa la coincidencia de expresiones regulares de derecha a izquierda. Y esto significa que la\1
referencia debe venir antes del(1+)
grupo de captura al que hace referencia.Pruébalo en línea.
fuente
Perl, 41 bytes
Incluye +1 para
-p
Dar secuencia de entrada en STDIN:
shift2048.pl
:fuente
Python, 61 bytes
El booleano
b
verifica si los dos últimos elementos deberían colapsar comprobando que son iguales de una manera segura para las listas de longitud 1 o 0. El último elemento si se agrega con un multiplicador de1
para igual o2
para desigual. Se agrega al resultado recursivo en la lista con tantos elementos cortados al final. ¡Gracias a Dennis por 1 byte!fuente
[l[-1]<<b]
Guarda un byte.l[-2:-1]
es[l[-2]]
Perl, 43 + 1 (
-p
) = 44 bytesA Ton Hospel se le ocurrió una respuesta de 41 bytes , ¡compruébalo!
-4 gracias a @Ton Hospel!
Editar : agregado
\b
, ya que sin él estaba fallando en la entrada como24 4
en la que habría sido la salida28
.Corre con
-p
bandera:No veo otra manera que usar
reverse
dos veces para doblar a la derecha (como solos/(\d+) \1/$1*2/ge
se doblaría a la izquierda, es decir,2 2 2
se convertiría en4 2
lugar de2 4
). Entonces 14 bytes perdidos gracias areverse
... Aún así, creo que debe haber otra (mejor) forma (¡es perl después de todo!), ¡Avíseme si lo encuentra!fuente
reverse reverse
Parece un poco largo. No soy un experto en Perl, pero ¿hay alguna manera de que puedas hacer un atajoreverse
(si no es nada, [ab] usandoeval
)?($_)
reverse
aparienciareverse
no se puede invocar sin argumento (bueno, los ejemplos muestran que puede ser, pero solo hay un prototipo:)reverse LIST
, así que olvidé$_
ser el argumento predeterminado;)LIST
puede estar vacío ...$_
como argumento predeterminado, el documento especifica un prototipo sin parámetros (comoprint
olenght
...). O tal vez esa es solo una impresión equivocada que tengo.JavaScript (ES6), 68 bytes
fuente
[1024, 1024, 512, 512, 256, 256]
está resolviendo como[2048, 512, 1024]
y no[2048, 1024, 512]
...?Perl 5.10,
6150 bytes (49+ 1 para bandera)¡Gracias a Ton Hospel por guardar 11 bytes!
Solución libre de expresiones regulares, con
-a
bandera:¡Intenta aquí!
fuente
@a=($F[-1]-$b?$b:2*pop@F,@a)while$b=pop@F;say"@a"
(50 bytes)JavaScript (ES6),
686558576564 bytesGuardado 1 byte gracias a @ l4m2
Se corrigió para las matrices sin clasificar ahora que se ha aclarado que tales entradas son de esperar.
fuente
a=>(a.reverse()+'').replace(/(.),\1/g,(c,i)=>i*2).split`,`.reverse()
?[1024, 1024, 512, 512, 256, 256]
(creo que este caso de prueba puede haberse agregado más tarde).f=(a,l=[],m)=>(x=a.pop())*!m-l?f(a,x).concat(l):x?f(a,2*x,1):[l]
?05AB1E , 26 bytes
Pruébalo en línea!
Pasos generalizados
fuente
Mathematica, 53 bytes
Explicación
Divida la entrada en sublistas que consisten en corridas de elementos idénticos. es decir se
{2, 2, 2, 4, 8, 8}
convierte{{2, 2, 2}, {4}, {8, 8}}
.Particione cada una de las sublistas en particiones de longitud como máximo 2. es decir, se
{{2, 2, 2}, {4}, {8, 8}}
convierte{{{2, 2}, {2}}, {{4}}, {{8, 8}}}
.Total de cada partición. es decir se
{{{2, 2}, {2}}, {{4}}, {{8, 8}}}
convierte{{4, 2}, {4}, {16}}
.Invierta los resultados porque el
Partition
comando de Mathematica va de izquierda a derecha, pero queremos que las particiones estén en otra dirección. es decir se{{4, 2}, {4}, {16}}
convierte{{2, 4}, {4}, {16}}
.Aplane el resultado. es decir se
{{2, 4}, {4}, {16}}
convierte{2, 4, 4, 16}
.fuente
Plus@@@
esTr/@
y creo que puedes evitar los paréntesis yJoin@@
si lo usas##&@@
en el resultado deReverse
(sin embargo, no lo he probado).Java 7, 133 bytes
Input es una ArrayList, y simplemente se repite, eliminando y duplicando donde sea necesario.
fuente
Long
referencias en la línea 3 con==
. Considerea.get(i)-a.get(i-1)==0
.Perl, 37 bytes
Incluye +4 para
-0n
Ejecute con la entrada como líneas separadas en STDIN:
shift2048.pl:
fuente
Haskell, 56 bytes
fuente
PHP,
86100 9994 bytesrequiere PHP 7.0; toma valores de los argumentos de la línea de comandos.
Ejecutar
-nr
o probarlo en línea .fuente
for($r=[];$v=($p=array_pop)($a=&$_GET[a]);)array_unshift($r,end($a)-$v?$v:2*$p($a));print_r($r);
es 1 Byte más cortoJulia 205 bytes
La función a llamar es
H
p.ej
H([1,2,2,4,8,2,])
Esta no es la manera más corta de hacerlo en julia. Pero es tan genial, que quería compartirlo de todos modos.
t(a)
es un tipo de valor, que representa el valor (a).s(a)
es una instancia de ese tipo de valorg
es una función que distribuye los valores de diferencia (usando los tipos de valor) y los números de sus parámetros. Y eso es genialK
simplemente envuelveg
para queParte extra genial:
Esto define el
^
operador para aplicar a las funciones. De manera queK^s(2)(X)
es igual queK(K(X))
lo queH
se acaba de llamarK
aK
un montón de veces - sin duda suficientes veces como para colapsar cualquier caso anidadaEsto se puede hacer mucho más corto, pero de esta manera es muy divertido.
fuente
PowerShell v2 +, 81 bytes
Toma la entrada como una matriz explícita
$n
, la invierte$n[$n.count..0]
,-join
junta los elementos con una coma, luego regexifica-replace
un par de dígitos coincidentes con el primer elemento, a*2
, y está rodeado por pares. Tuberías que resultan (que@(2,2,4,4)
se verá como entrada(4*2),(2*2)
) aiex
(abreviaturaInvoke-Expression
y similar aeval
), que convierte la multiplicación en números reales. Almacena la matriz resultante en$b
, encapsula eso en parens para colocarlo en la tubería, luego invierte$b
con[$b.count..0]
. Deja los elementos resultantes en la tubería, y la salida es implícita.Casos de prueba
NB: en PowerShell, el concepto de "devolver" una matriz vacía no tiene sentido, se convierte en
$null
tan pronto como sale del alcance, por lo que es el equivalente a no devolver nada, que es lo que se hace aquí en el primer ejemplo (después de algunos errores malvadamente verbosos). Además, la salida aquí está separada por espacios, ya que es el separador predeterminado para las matrices en cadena.fuente
Javascript - 103 bytes
fuente
[2,2,4,4]
rendimientos[2,2,4,4]
.Brain-Flak , 60 bytes
Pruébalo en línea!
Explicación:
fuente
Python 2, 94 bytes
Pruébalo en línea
fuente
Julia,
7382 bytesUse el pliegue derecho para construir la lista de atrás hacia adelante (también se puede usar doblar a la izquierda e invertir la lista al principio y al final).
Si el encabezado de la lista actual no es igual al siguiente elemento a anteponer, simplemente añádalo.
De lo contrario, elimine el encabezado de la lista (suena un poco cruel) y anteponga el elemento por 2.
Ejemplo
fuente
Raqueta 166 bytes
Sin golf:
Pruebas:
Salida:
fuente
Japt , 12 bytes
Pruébalo en línea!
Desempaquetado y cómo funciona
Tengo una idea de la solución Jelly de Jonathan Allan .
fuente
Mathematica, 51 bytes
{Longest@a___,x_/;x>0,x_,b___}
coincide con una lista que contiene dos números positivos idénticos consecutivos y transforma estos dos números en-2x
.Longest
obliga a los partidos a suceder lo más tarde posible.El proceso se ilustra paso a paso:
fuente
Vim, 28 bytes
G@='?\v(\d+)\n\1<C-@>DJ@"<C-A>-@=<C-@>'<CR>
Una macro que regex busca hacia atrás para buscar números consecutivos y los agrega.
La matriz de entrada debe ser un número por línea. Este formato me ahorra trazos, lo cual es bueno, pero la verdadera razón es evitar coincidencias de expresiones regulares superpuestas. Dada la cadena
222
, si/22
solo coincidirá con el primer par, no con el segundo par superpuesto. Las reglas de superposición son diferentes cuando los dos pares comienzan en líneas diferentes. En este desafío se[2, 2, 2]
hace[2, 4]
, por lo que emparejar el par superpuesto es crítico.NOTA: El desafío solo requería un solo pase. Por esa razón, necesitas tener
:set nowrapscan
. Con:set wrapscan
podría hacer una versión que termine el trabajo en múltiples pases, aunque esta solución tal como está escrita no siempre lo hará.<C-@>
: Normalmente, en una línea de comando, para escribir un literal<CR>
sin ejecutar el comando con el que tendría que escapar<C-V>
. Pero puede escribir<C-@>
sin escape y se tratará como un<C-J>
/<NL>
, que será como<CR>
cuando ejecuta la macro pero no cuando está escribiendo. Intenta leer:help NL-used-for-Nul
.@=
: No puedo usar una macro grabada fácilmente esta vez porque existe la posibilidad de que la entrada no tenga pares coincidentes. Si eso sucede mientras se ejecuta una macro, la búsqueda fallida fallará en la macro. Pero si sucede durante el pase de grabación (primero implícito), el resto de los comandos del modo normal se ejecutarán, dañando el archivo. La desventaja@=
es que pierdo un byte en la llamada recursiva; a veces se puede usar@@
como una llamada recursiva, pero eso se ejecutaría@"
desde 4 bytes anteriormente en este caso.DJ@"<C-A>-
:DJ
elimina la línea y coloca el número (sin nueva línea) en un registro, para que pueda ejecutarlo como una macro para un argumento de número<C-A>
. Tengo que hacerlo-
después para no tener un segundo partido en casos como[4, 2, 2]
.fuente
Perl6, 92 bytes
fuente
Prólogo (SWI) ,
9787 bytesPruébalo en línea!
fuente