Dada una ecuación lineal mx+n, retorno ny m. Sin embargo, la ecuación puede estar en cualquiera de los siguientes formatos:

5x+2 -> 5 2
5x-2 -> 5 -2
5x   -> 5 0
-2   -> 0 -2
x    -> 1 0

Aquí están los formatos, donde cada uno ?representa un entero positivo escrito sin ceros a la izquierda

?x+?
?x-?
-?x+?
-?x-?
x+?
x-?
?
-?
?x
-?x
x

Todos estos casos deben ser manejados.

Especificaciones:

• Puede suponer que la ecuación está en uno de los formatos anteriores, es decir, coincide con la expresión regular ^(-?[123456789]\d*)?x([+-][123456789]\d*)?|-?[123456789]\d*$.

Casos de prueba:

-2x+3 -> -2 3
44x   -> 44 0
-123  -> 0 -123
x     -> 1 0
-1x   -> -1 0

Python 2 , 55 bytes

j=1j
c=eval(input().replace(*'xj'))
print c.imag,c.real

Pruébalo en línea!

Utiliza la evaluación de código incorporada de Python. La entrada se formatea como un número complejo al reemplazarla xcon jla unidad compleja de Python. Debido a que solo 2jse reconocen literales como , pero no jo -j, la variable jse asigna 1jpara cubrirlos.

Desafortunadamente, Python no parece tener una función integrada para convertir un número complejo en un par de reales.

Mathematica, 16 bytes

Inspirado por la respuesta de xnor's Python 2 :

ReIm[I#/.x->-I]&

Toma la entrada como una expresión literal (no una cadena) y devuelve un par de números. Funciona haciendo xun número complejo y luego tomando las partes reales e imaginarias: el único bit no obvio es multiplicar por i para comenzar, para obtener la salida en el orden correcto.

También podemos usar

ReIm[x=-I;I#]&

para 14 bytes (¡empatado con Jelly!), pero establecer el valor xigual a -i antes de tomar la entrada, en lugar de simplemente reemplazar xdespués, se siente como hacer trampa ...

JavaScript (ES6), 53 48 bytes

s=>([a,b]=s.split(/x\+?/),1/b?[a||1,b||0]:[0,s])

Casos de prueba

let f =

s=>([a,b]=s.split(/x\+?/),1/b?[a||1,b||0]:[0,s])

console.log(f("-2x+3")) // -> -2 3
console.log(f("44x"))   // -> 44 0
console.log(f("-123"))  // -> 0 -123
console.log(f("x"))     // -> 1 0
console.log(f("-1x"))   // -> -1 0

sed , 44 42 bytes

s:+::
s:x: :
t
s:^:0 :
:
s:^ :1 :
s: $: 0:

Pruébalo en línea!

I / O: uno por línea.

-2 bytes gracias a @KritixiLithos.

Jalea , 18 14 bytes

”x;ṣ”xVṫ-µ¬ṂW+

Test suite en Pruébelo en línea!

¿Cómo?

”x;ṣ”xVṫ-µ¬ṂW+ - Main link: list of characters s  examples: "5x-2"         "x"       "-123"
”x             - literal 'x'
  ;            - concatenate with s                        "x5x-2"        "xx"      "x-123"
   ṣ”x         - split on 'x's                        ["","5","-2]  ["","",""]  ["","-123"]
      V        - evaluate as Jelly code (vectorises)      [0,5,-2]     [0,0,0]     [0,-123]
       ṫ-      - tail from index -1 inclusive               [5,-2]       [0,0]     [0,-123]
         µ     - monadic chain separation (call that z)
          ¬    - not z                                       [0,0]       [1,1]        [1,0]
           Ṃ   - minimum                                         0           1            0
            W  - wrap in a list                                [0]         [1]          [0]
             + - add to z (vectorises)                      [5,-2]       [1,0]     [0,-123]

PHP, 73 bytes

preg_match("#((.*)x)?\+?(.*)#",$argn,$t);echo$t[1]?$t[2]?:1:0," ",+$t[3];

Pruébalo en línea!

PHP, 91 bytes

trabaja también con -x

preg_match("#((-)?(\d+)?x)?\+?(-?\d+)?#",$argn,$t);echo$t[2],$t[1]?$t[3]?:1:0," ",$t[4]?:0;

Pruébalo en línea!

Mathematica, 23 bytes

Coefficient[#,x,{1,0}]&

Pruébalo en línea

copia y pega con ctrl-v este código

Coefficient[#,x,{1,0}]&[-2x+3]

y presiona shift + enter para ejecutar

Python 2 , 71 bytes

lambda s:([0,]+[int(x or`1-i`)for i,x in enumerate(s.split('x'))])[-2:]

Pruébalo en línea!

Mathematica, 33 bytes

#~CoefficientList~x/.{a_}:>{a,0}&

Función pura que toma una expresión en el formato esperado (nota: no una cadena, sino una expresión pura como -2x+3), y devuelve un par ordenado de enteros con el coeficiente constante que aparece primero (por ejemplo, -2x+3retornos {3,-2}).

El builtin CoefficientList(que funciona para polinomios de cualquier grado) hace el trabajo pesado; su comportamiento predeterminado es devolver constantes como listas de longitud 1, por lo /.{a_}:>{a,0}que anula eso y hace que el 0coeficiente de xaparezca explícitamente.

Retina , 38 bytes

x$
x+0
^[^+-]*$
0x+$+
^[^-\d]
1$+
-
+-

Definitivamente se puede mejorar.

Posiblemente estirando cómo se nos permite formatear la salida. Simplemente genera una ecuación completa, como en ny mseparada porx+

Pruébalo en línea!

Octava , 45 bytes

@(a)[imag(u=eval(strrep(a,'x','j'))),real(u)]

Pruébalo en línea!

Evaluar la expresión, con xreemplazado por complejo j. Octava es muy flexible cuando se trata de expresiones complejas, con j, 1j, iy 1itodas equivalentes (con la ventaja de que 1jy 1ino puede ser sobrescrito por variables, pero eso es irrelevante para este desafío). La expresión en línea se utiliza para crear una lista [imag(u) real(u)]con uel número complejo.

Inicialmente quería probar un enfoque más idiomático, utilizando el incorporado sym2poly. Por ejemplo (ya en 47 bytes para asegurarse de que 0*xse maneja):

@(a)sym2poly([strrep(a,'x','*x') '+x^2']))(2:3)

Sin embargo, éste falló en el caso de xsin coeficiente. Al final, una configuración real / compleja como xnorresultó ser óptima.

MATL , 12 bytes

120'i'ZtU&Zj

Pruébalo en línea!

Respuesta de Port of my Octave, pero por supuesto adaptada para compacidad en MATL. Explicación:

120'i'Zt     % Replace character 120 ('x') by 'i' in input (implicit).
             % (Used 120 instead of 'x' to save a separator between 'x' and 'i')
        U    % Convert string to complex number
         &Zj % Split complex number in real and imaginary part. Implicit display.

C (gcc) , 145 138 112 bytes

f(char*s){int a,b,i=0;sscanf(s,"%dx%d",&a,&b);if(L!=0)i=(int)(L-s);printf("%d %d",s[i]=='x'?a:0,s[i]=='x'?b:a);}

Pruébalo en línea!

void f(char*s)
{
    int a,b,i=0;
    sscanf(s,"%dx%d",&a,&b);

    if(L!=0)
      i=(int)(L-s);

    printf("%d %d",s[i]=='x'?a:0,s[i]=='x'?b:a);
}

Definitivamente se puede acortar, ¡pero no lo veo ahora!