Tienes varios polinomios que están solos, ¡así que conviértelos en compañeros (que no amenacen con apuñalar)!
Para un polinomio de grado n
, hay una matriz de cubon by n
compañera para él. Debe realizar una función que acepte una lista de coeficientes para un polinomio en orden ascendente ( ) o descendente ( ) (pero no en ambos) y generar la matriz complementaria. a + bx +cx^2 + …
ax^n + bx^(n-1) + cx^(n-2)+…
para un polinomio c0 + c1x + c2x^2 + ... + cn-1x^(n-1) + x^n
, su matriz compañera es
(0, 0, 0, ..., -c0 ),
(1, 0, 0, ..., -c1 ),
(0, 1, 0, ..., -c2 ),
(...................),
(0, 0, ..., 1, -cn-1)
tenga en cuenta que el coeficiente para x^n
es 1. Para cualquier otro valor, divida el resto de los coeficientes por x^n
's. Además, los 1 están desplazados de la diagonal.
Si el idioma que está utilizando ya contiene una función o módulo que hace esto, no puede usarlo, debe escribir el suyo.
Por ejemplo, si tuviera 4x^2 – 7x + 12
, los coeficientes en orden ascendente son (12, -7, 4)
y en orden descendente (4, -7, 12)
. La función o el programa deben salir [(0, -3.0), (1, 1.75)]
para cualquier orden. Especifique qué orden acepta su código. El polinomio mínimo debe ser cuadrático. Los coeficientes están restringidos a números reales.
A continuación se muestran ejemplos: su salida no tiene que coincidir con el formato bonito, pero debe generar las filas (en el ()
) de la matriz en orden.
Orden ascendente:
input:
[3., 7., -5., 4., 1.]
output:
[(0, 0, 0, -3.),
(1, 0, 0, -7.),
(0, 1, 0, 5.),
(0, 0, 1, -4.)]
input:
[-4., -7., 13.]
output:
[(0, 0.30769231),
(1, 0.53846154)]
input:
[23., 1., 92., 8., -45., 88., 88.]
output:
[(0, 0, 0, 0, 0, -0.26136364),
(1, 0, 0, 0, 0, -0.01136364),
(0, 1, 0, 0, 0, -1.04545455),
(0, 0, 1, 0, 0, -0.09090909),
(0, 0, 0, 1, 0, 0.51136364),
(0, 0, 0, 0, 1, -1. )]
Orden descendiente:
input:
[1., 4., -5., 7., 3.]
output:
[(0, 0, 0, -3.),
(1, 0, 0, -7.),
(0, 1, 0, 5.),
(0, 0, 1, -4.)]
input:
[13., -7., -4.]
output:
[(0, 0.30769231),
(1, 0.53846154)]
input:
[88., 88., -45., 8., 92.,1., 23.]
output:
[(0, 0, 0, 0, 0, -0.26136364),
(1, 0, 0, 0, 0, -0.01136364),
(0, 1, 0, 0, 0, -1.04545455),
(0, 0, 1, 0, 0, -0.09090909),
(0, 0, 0, 1, 0, 0.51136364),
(0, 0, 0, 0, 1, -1. )]
¡Dennis gana con 20 bytes!
Respuestas:
CJam,
2320 bytesEsta es una función que saca la entrada (orden ascendente) de la pila y empuja la salida a cambio.
Pruébelo en línea en el intérprete de CJam .
Cómo funciona
fuente
CJam,
323128 bytesPruébalo en línea
Esto toma la entrada en orden ascendente, utilizando el formato de lista CJam. Entrada de muestra:
Explicación:
fuente
APL,
4030 bytesAcepta entradas en orden ascendente.
Explicación:
Pruébalo en línea
fuente
Julia, 43 bytes
Esto usa orden descendente para la entrada. Construye la matriz girada 180 grados, para permitir un uso más eficiente del "ojo", luego gira la matriz en la orientación correcta.
fuente
Julia,
6444 bytesAcepta un vector de los coeficientes en orden ascendente.
Sin golf:
Pruébalo en línea
Ahorró 20 bytes gracias a Glen O!
fuente
R,
7159 bytesToma entrada en orden ascendente.
Sin golf:
fuente
Matlab, 66 bytes
Utiliza el orden ascendente para la entrada, con formato
[3., 7., -5., 4., 1.]
o[3. 7. -5. 4. 1.]
.Pruébelo en línea (en octava).
Ejemplo (en Matlab):
Si un programa es válido (en lugar de una función), con stdin y stdout:
Matlab, 59 bytes
fuente
n=numel(c=input(''));
n=numel(input(''))
sería válido, pero necesito volver a usarloc
más tardeOctava,
4544 bytesSuponiendo que
c
es un vector de columna con el coeficiente de la potencia más altax
al final.Versión antigua:
¡Choca los cinco, Julia!
fuente
Python 2, 141 bytes
Mi propio intento:
Toma una lista de los coeficientes en orden descendente y primero construye la transposición de la matriz compañera, conocida por apuñalar y ser hablador. La devolución usa zip para producir la transposición de esta transposición para obtener la matriz real.
fuente
JavaScript (ES6) 85
Orden ascendente
Pruebe a ejecutar el fragmento a continuación en cualquier navegador compatible con EcmaScript 6.
fuente
TI-BASIC, 50 bytes
Toma entrada en orden ascendente. Tenga en cuenta que esto no funcionará para polinomios de grado <2, porque TI-BASIC no admite matrices o listas vacías. En espera de una decisión de OP, puedo arreglar esto a costa de unos pocos bytes.
Primero, almacenamos la lista
∟X
para usar el último elemento más tarde; luego, calculamosΔList(Ans-cumSum(Ans))
, que es solo la lista negada con el último elemento cortado, y la convertimos en un vector de columna. ComoList▶matr(
no se modificaAns
, podemos usar la siguiente línea para tomar la dimensión de la lista, que usamos tres veces. TI-BASIC no tiene concatenación vertical, por lo que debemos tomar transposiciones y concatenar horizontalmente. En la última línea,[A]/∟X(Ans
no funcionaría porque las matrices pueden multiplicarse por escalares pero no dividirse.Un aparte: para generar el vector fila de ceros, aprovechamos el
randM(
comando raramente útil .randM(
crea una matriz aleatoria, pero sus entradas son siempre enteros aleatorios entre -9 y 9 (!), por lo que en realidad solo es útil crear matrices cero.fuente
Pari / GP , 49 bytes
Pruébalo en línea!
fuente