Dada una matriz no vacía de enteros positivos, "incremente" una vez de la siguiente manera:
Si todos los elementos de la matriz son iguales, agregue
1
a al final de la matriz. Por ejemplo:[1] -> [1, 1] [2] -> [2, 1] [1, 1] -> [1, 1, 1] [3, 3, 3, 3, 3] -> [3, 3, 3, 3, 3, 1]
De lo contrario, incremente el primer elemento de la matriz que es el valor mínimo de la matriz. Por ejemplo:
[1, 2] -> [2, 2] [2, 1] -> [2, 2] [3, 1, 1] -> [3, 2, 1] -> [3, 2, 2] -> [3, 3, 2] -> [3, 3, 3] [3, 4, 9, 3] -> [4, 4, 9, 3] -> [4, 4, 9, 4] -> [5, 4, 9, 4] -> [5, 5, 9, 4] -> ...
(Cada ->
uno representa un incremento, que es todo lo que su programa necesita hacer).
Salida de la matriz incrementada resultante.
El código más corto en bytes gana.
code-golf
number
arithmetic
array-manipulation
integer
Pasatiempos de Calvin
fuente
fuente
Respuestas:
Jalea ,
87 bytesPruébalo en línea! o verificar todos los casos de prueba .
Cómo funciona
fuente
Python 3,
62535150 bytesFunción que modifica la lista que se le pasa ( permitida por meta ).
Prueba en repl.it!
-9 bytes gracias a Lynn por detectar eso, debido a que la matriz será de enteros positivos, puedo agregar '0' al final de la matriz y aumentar eso.
Un agradecimiento especial a mbomb007 para jugar al golf
len(set(a))
alen({*a})
, y Dennis para el truco floordiv!fuente
len({*L})<2
para encontrar si todos los elementos de una lista son iguales.a+=1//len({*a})*[0]
Debería guardar un byte.JavaScript (ES6), 61 bytes
Salidas modificando su argumento . No puedo encontrar una manera de determinar si una matriz tiene solo un elemento único en menos de 17 bytes, pero las sugerencias son bienvenidas.
Fragmento de prueba
Mostrar fragmento de código
Otros intentos
Aquí hay algunas formas alternativas de decidir si la matriz tiene más de una entrada única:
Ambos
some
s también pueden reemplazarsefind
..sort
sería más corto para encontrar el mínimo, si la ordenación predeterminada no fuera lexicográfica (¿por qué, JS, por qué?):Intenté la recursividad para encontrar el mínimo, pero resultó mucho más tiempo:
Y aquí hay una solución basada en cadenas que parecía una buena idea al principio: (la entrada se da en formato de matriz en una cadena, por ejemplo
"[1,2,3]"
)fuente
Mathematica,
705755 bytes¡Prácticamente toda la mejora se debe a Martin Ender, quien me patea el culo en los enfoques de coincidencia de patrones! Además, a JHM se le ocurrió esencialmente la misma solución al mismo tiempo. (el recuento de bytes utiliza la codificación ASCII)
Define una función que
±
toma un argumento de lista. Si ese argumento de la lista contiene cierto número de copias del mismo elemento (detectadox_..
y nombradop
), entonces envíe la lista con un1
anexo. De lo contrario, si ese argumento de la lista tiene un elemento especialy
(x
siendo el cero o más elementos antesy
, yz
siendo el cero o más elementos despuésy
) que es, como máximo, el mínimo de los otros elementos, entonces genera la lista con esoy
incrementado. Cualquier instancia del elemento mínimo de la lista será igualaday
, pero afortunadamente Mathematica elige la primera para actuar.fuente
±
es un carácter de 2 bytes, su código tiene una longitud de 59 bytes. Además, debe haber un espacio entrex_
y..
porque Mathematica interpretax_..
comox_. .
(que arroja errores). Además, la forma infija deMin
(x~Min~z
) acortaría estos 2 bytes (lo que hace que esta solución sea idéntica a la mía: p ...) Bueno, puedes tomar el crédito porque mi edición fue posterior a la tuya ...±
en UTF-8 ( Mathematica usa UTF-8 por defecto; try$CharacterEncoding
) es un carácter de dos bytes (U + 00B1).±
.$CharacterEncoding
establecido enWindowsANSI
CP1252 (que es lo suficientemente compatible con ISO 8859-1±
y·
que se puede usar para un solo byte).C ++ 14,
178176174155142135bytessumisión
invocación
sin golf
Esta es mi primera vez jugando al golf, se agradece la ayuda.
EDITAR: olvidé mencionar que tienes que compilarlo al menos
-std=c++11
-std=c++14
EDIT2: me di cuenta de que puedo dejar el espacio en el incluye
#include <list>
EDITAR3: guardado dos bytes más al reemplazar
l.begin()
porbegin(l)
EDIT4: guardó otros 19 (!) Bytes gracias a @Quentin (vea su comentario)
EDITAR5: Quentin recortó 13 bytes más, ¡gracias!
EDIT6: como TuukkaX señaló, las funciones / lambdas sin nombre son suficientes, así que
auto i=
eliminé el en el bytecountfuente
#include
líneas.auto i=[](auto&l){...};
) ahorra un byte (más si contamos el tipo de retorno que olvidó;)), usar en^
lugar de==
e intercambiar los operandos guarda otro.std::list
Los iteradores son, sin dudastd::
, clases, por lo que puede abandonarstd::
ambosstd::count
ystd::min_element
gracias a ADL (-10).l.front()
es también*b
(-7). Termino con una 120 bytesauto i=[](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?void(++*find(b,e,*min_element(b,e))):l.push_back(1);};
:)std::min_element
afirma que devuelve el primer elemento más pequeño, por lo quefind()
es superfluo, eso es 11 bytes. En el condicional, usar un par de paréntesis y el operador de coma para coaccionar la expresión correctaint
es más corto que convertir el izquierdo envoid
2 bytes. Esto lleva aauto i=[](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?++*min_element(b,e):(l.push_back(1),0);};
142 bytes :)05AB1E ,
212016 bytesGuardado 4 bytes gracias a Adnan .
Pruébalo en línea!
Explicación
fuente
DÙgi0¸«}ÐWksgÝQ+
también funciona.ÝQ
conk
. ¡Gracias!Scratch,
2534 bloques +76 bytesToma datos como una matriz predefinida de enteros. Tenga en cuenta que las matrices están indexadas en 1 en Scratch.
En Python, esto se vería así: (Tenga en cuenta que, a diferencia de Scratch, Python tiene un índice 0)
fuente
J,
2522 bytesEvalúa a un verbo anónimo. ¡Pruébelo en línea!
Explicación
fuente
MATL , 16 bytes
Pruébalo en línea! O verificar todos los casos de prueba
Cómo funciona
fuente
Mathematica, 56 bytes
Utiliza la función con nombre
±
. Utiliza codificación ISO8859-1Soluciones alternativas (58 bytes)
Uso
fuente
Haskell,
71 7062 bytes@ Zgarb ahorró 8 bytes, ¡gracias!
Cuando comencé, esperaba un truco elegante para atar el nudo, pero el camino de @ Zgarb es igual de sorprendente.
fuente
f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1:z
(->)r
, que se aplica a un tipo es(->)r a = r->a
. Entonces, de los tiposreturn:: a->r->a
y(>>=)::(r->a)->(a->r->b)->(r->b)
su implementación es (¿me atrevo a decirlo?) Obvio:return=const
ym>>=f = \r->f(m r)r
. Esto último es exactamente lo que se necesita para expresar algo así comospan(predicate_depending_on l)l
mencionarl
solo una vez. Ahora solo necesito recordarlo cuando lo necesito.C #,
1231211207977 bytesModifica el argumento pasado a la función.
¡Gracias a Cyoce por guardar 3 bytes! ->
!Any
aAll
,+=1
a++
.¡Gracias a TheLethalCoder por guardar la friolera de 43 bytes! -> Código de firma del método eliminado. Se eliminó el paréntesis alrededor de la lista de parámetros.
fuente
!l.Any(o=>o!=l[0]))
conl.All(o=>o==l[0])
?Any
lugar deAll
pensar que no funciona: D ¡Gracias!++
?Action<List<int>>
para eliminar todo el código de firma del métodousing
s necesarios con C #, por lo que no confío en que sea legal dejarlosusing System.Linq
. A menos que vea una declaración explícita que diga que esto no es necesario, me quedaré con esto. Gracias por la sugerencia sin embargo! :)Perl 6 , 46 bytes
(modifica la matriz de entrada y la devuelve)
Expandido:
fuente
Jalea, 9 bytes
Gracias a Dennis por los -2 bytes.
El cuerpo debe tener al menos 30 caracteres; entraste ... .
fuente
Mathematica,
53 bytes57 bytes59 bytesfuente
〚
y〛
son caracteres de 3 bytes. Además, su código no funciona porque{##,1}
parte implica que la entrada es enteros separados (es decirf[1, 2, 3]
), pero lax=#
parte implica que la entrada es unList
(es decirf[{1, 2, 3}]
). Una solución rápida sería cambiarx=#
ax={#}
y aceptar enteros crudos como entrada, por lo que su código de 59 bytes de longitud.Equal@#
, aunque#==##
es más corto.R ,
72 6665 bytesPruébalo en línea!
El incremento se realiza utilizando el
which.min
que devuelve la primera coincidencia."[<-"
permite reemplazar el valor y devuelve el vector modificado en una llamada de función.-7 bytes gracias a Giuseppe!
fuente
!=
con-
!Ruby, 46 bytes
Siento que hay una mejor manera de verificar si todos los elementos son iguales
a.uniq.size<2
, pero soy demasiado vago para encontrarlo.fuente
a.uniq[1]
será verdad si hay valores distintos.a[a.index(a.min)]
ena[a.index a.min]
Octava,
696764 bytesEn realidad, fue más corto hacer de esta una función completa con nombre que usar ambos
input
ydisp
.Guardado 3 bytes gracias a Luis.
Respuesta anterior, sin usar una función:
fuente
R, 97 bytes
¡Lástima que el sinthax
x=+1
no exista en R!Sin golf:
fuente
TI-Basic, 53 bytes
fuente
Matlab,
83,77, 71 bytesSoy relativamente nuevo en el código de golf, ¡así que sé amable! Traté de usar funciones anónimas, pero Google dice que no puedes usar declaraciones if / else y matlab no tiene operadores ternarios, así que esto es lo mejor que sentí que podría hacer.
Editar: corregido y acortado (¡dos veces!) Gracias a stewie-griffin.
fuente
sum(a)/length(a)==a(1)
no garantiza que todos los elementos sean iguales, solo muestra que el promedio es igual aa(1)
. Una forma más sencilla de hacer esto seríamean(a)==a(1)
.numel
es un byte más corto quelength
, pero como sabe que todos los valores son positivos, puede usar unonnz
que sea aún más corto (todavía no daría el resultado correcto en este desafío, pero al menos es más corto: P). Si toma lamin(a)
llamada frente al bucle, puede usar ambas salidas y verificar si losall
elementosa
son iguales amin(a)
.~nnz(a(a~=a(1)))
es simplemente~nnz(a-a(1))
. Además, no necesitas los paréntesis.if ~nnz(a-a(1));a=[a,1];else[~,I]=min(a);a(I)=a(I)+1;end
. Esto debería ser 5 bytes más corto (nota: no lo he probado).range(a)
lugar dennz(a-a(1))
a
es igual al valor más bajo en ese vector. Un vectora = [3 4 6]
dará como resultadotrue
, y un vectora = [4 4 6]
dará como resultadofalse
. No creo que eso sea útil aquí ...?Clojure,
112100 bytesDesafortunadamente,
min-key
devuelve el último índice del índice más pequeño, no el primero. Esto funciona para entradas enteras y matrices más cortas que 10 ^ 9 elementos;)Editar: Definir una función anónima, usando en
(apply = a)
lugar de(= 1(count(set a)))
.Original:
Una solución menos hacky de 134 bytes invierte el vector antes de actualizarlo y luego lo invierte nuevamente:
fuente
Java 8, 85 + 38 = 123 bytes
La lambda vacía toma un
List<Integer>
(la salida es entrada mutada). El recuento de bytes incluye lambda y la importación requerida.Pruébalo en línea
Esto casi parece Python con esas importaciones de métodos ...
fuente
MATLAB,
6653 bytesSalida:
Inicializar:
Carreras sucesivas:
fuente
@(x) …
.SmileBASIC 3, 101 bytes
Define una función de declaración
I A
dondeA
está nuestra matriz de números enteros. La salida se logra modificando la entrada (ya que las matrices son referencias).fuente
BREAK
conM=0
, porqueA
no puede contener,0
porM==A[C]
lo que nunca será cierto.SmileBASIC, 77 bytes
fuente
Pyth, 16 bytes
Un programa que toma la entrada de una lista e imprime el resultado.
Banco de pruebas
Cómo funciona
fuente
Haskell, 93 bytes
f z|and$(==)<$>z<*>z=z++[1]|1>0=z#minimum z where(x:z)#m|x==m=x+1:z;(x:z)#m|1>0=x:z#m;[]#_=[]
Sin golf:
Intento inicial, intentará encontrar algo más sofisticado más adelante.
fuente
where
?Maravilla , 44 bytes
Esto no es lo que tenía en mente cuando hice este lenguaje ... ¡Es literalmente peor que Perl en términos de legibilidad!
Uso:
Explicación
Más legible:
Básicamente verifica si al soltar 1 elemento del subconjunto único del argumento, la lista está vacía. Si no, entonces incrementamos el mínimo de la matriz. De lo contrario, simplemente concatenamos 1 al argumento.
fuente
Kotlin, 75 bytes
Modifica el argumento de la función.
¡Maldita sea tipeo fuerte!
:MutableList<Int>
representa 17 bytes solo. Lamentablemente, no creo que haya una solución en la que se pueda inferir el tipo.fuente