Un párrafo de texto tiene números y letras alfabéticas mezcladas. Su tarea es separar los números del lado izquierdo y las letras alfabéticas del lado derecho en el mismo orden de cada línea.

Reglas:

1. Los números son enteros simples; así que no hay punto decimal, ni signos negativos / positivos.
2. Los números pueden o no ser contiguos, pero cualquiera que sea el caso, deben empujarse hacia el lado izquierdo en el mismo orden.
3. Los números pueden aparecer entre palabras.
4. El texto contiene solo letras y números alfabéticos ASCII, junto con espacios, guiones bajos, comas y puntos.
5. El que hace esto con un mínimo de pulsaciones de teclas (como las macros vim) o la menor cantidad de bytes en caso de secuencias de comandos es el ganador.

Texto de ejemplo:

A word can have any number of text like 433884,
but all the numb89ers has to be moved left side 
but alph6abetical va9lues has to be pas46ted on right side.
The text might con4tain chara29cters s2huffled like hlep or dfeintino or even
meaningless1 words co43mbined togeth81er.

Rendimiento esperado:

433884A word can have any number of text like ,
89but all the numbers has to be moved left side 
6946but alphabetical values has to be pasted on right side.
4292The text might contain characters shuffled like hlep or dfeintino or even
14381meaningless words combined together.

Retina , 14 bytes

O%$`\d|(.)
$#1

Pruébalo en línea!

Explicación

Ointroduce una etapa de clasificación. %le dice a Retina que aplique la transformación a cada línea por separado. $le dice que ordene las coincidencias por el resultado de la sustitución especificada.

La expresión regular en sí es la \d|(.)que coincide con un dígito o cualquier otra cosa que se captura en el grupo 1. Esto se sustituye con $#1cuál es el número de capturas de grupo 1. Es decir, la clave de clasificación para los dígitos es 0y la clave de clasificación para todo lo demás es 1. Como la ordenación en Retina es estable, esto simplemente mueve los dígitos a la izquierda y todo lo demás a la derecha.

05AB1E, 14 10 bytes

Código:

|vyþyyþ-¶J

Explicación:

|                 # push all lines in input as array of strings
 v                # for each line in array
  yþ              # push only digits from line
    yyþ-          # push line without digits
        ¶         # push newline char
         J        # join as string
                  # end loop and print explicitly

Entrada de ejemplo:

Una palabra puede tener cualquier cantidad de texto como 433884,
pero todos los números entumecidos deben ser movidos del lado izquierdo,
pero los valores alfabéticos tienen que ser pasados ​​del lado derecho.
El texto puede contener caracteres caracterizados como hlep o dfeintino o incluso
palabras sin sentido combinadas entre sí.

Salida de ejemplo:

433884 Una palabra puede tener cualquier cantidad de texto como,
89 pero todos los números tienen que ser movidos del lado izquierdo
6946 pero los valores alfabéticos deben ser pegados en el lado derecho.
4292 El texto puede contener caracteres mezclados como hlep o dfeintino o incluso
4381 palabras sin sentido combinadas.

Pruébalo en línea

Python 3, 64 bytes

¡Tres soluciones equivalentes! No puedo escoger

while 1:print(*sorted(input(),key=lambda x:-x.isdigit()),sep='')
while 1:print(*sorted(input(),key=lambda x:x<'0'or'9'<x),sep='')
while 1:print(*sorted(input(),key=str.isdigit,reverse=1),sep='')

Perl, 17 bytes

Código de 16 bytes + 1 interruptor

s/\d/!print$&/ge

Requiere -p.

Uso

perl -pe 's/\d/!print$&/ge' <<< 'a1b2c3d4e5f6'
123456abcdef

Alternativamente:

print/\d/g,/\D/g

Requiere -n.

Uso

perl -ne 'print/\d/g,/\D/g' <<< 'a1b2c3d4e5f6'
123456abcdef

Hoon , 92 83 bytes

|*
*
(turn (lore +<) |=(@ `tape`(welp (skid (trip +<) |=(@ !=(~ (rush +< nud)))))))

++loredivide un cable de varias líneas en un (list cord), lo (trip +<)convierte en una cinta. ++skidsepara una lista en dos: un lado donde la función devuelve sí, un lado donde devuelve no. Nuestra función intenta analizar el carácter con ++nud(numérico) y verifica si se analiza por completo, y luego soldamos las dos listas nuevamente en una cinta.

> %.
  '''
  A word can have any number of text like 433884,
  but all the numb89ers has to be moved left side 
  but alph6abetical va9lues has to be pas46ted on right side.
  The text might con4tain chara29cters s2huffled like hlep or dfeintino or even
  meaningless1 words co43mbined togeth81er.
  '''
  |*
  *
  (turn (lore +<) |=(@ `tape`(welp (skid (trip +<) |=(@ !=(~ (rush +< nud)))))))
<<
  "433884A word can have any number of text like ,"
  "89but all the numbers has to be moved left side "
  "6946but alphabetical values has to be pasted on right side."
  "4292The text might contain characters shuffled like hlep or dfeintino or even"
  "14381meaningless words combined together."
>>

MATL , 13 12 bytes

`jt4Y2m&)hDT

Sale con un error (permitido por defecto), produciendo la salida correcta.

Pruébalo en línea!

Explicación

`          T    % infinite loop
 j              % input one line as a string
  t             % duplicate
   4Y2          % predefined literal: '0123456789'
      m         % true for elements of string that are digits, false for the rest
       &)       % two-output indexing: push digits, then non-digits
         h      % concatenate the two strings
          D     % display

V, 12 bytes

òí¨Ä©¨ä©/²±
​

V, es un lenguaje de golf basado en cadenas 2D sin terminar. Aunque no está terminado, este programa funciona a partir de commit 45 , que se publicó anoche, lo que lo convierte en una respuesta competitiva. (La mayoría de mis respuestas V anteriores no eran competitivas).

Tenga en cuenta que la nueva línea final es necesaria, aunque esto se debe a un error.

Pruébalo en línea!

Explicación:

ò            #Recursively, do:
 í           #Substitute on every line
  ¨Ä©¨ä©/²±  #The following regex. 

¨Ä©¨ä©/²± se expande en la expresión regular vim:

:%s/\(\D\)\(\d\)/\2\1

que es un no dígito (\D)seguido de un dígito (\d), y cambiarlos.

Como esto está lleno de caracteres unicode gruesos, aquí hay un hexdump reversible:

00000000: f2ed a8c4 a9a8 e4a9 2fb2 b10a            ......../...

Javascript ES6, 40 bytes

a=>a.replace(/\D/g,'')+a.replace(/\d/g,'')

Intenté varias otras soluciones, pero no pude hacerlo más pequeño que esto.
Mi primer intento fue a=>[...a.match(/\d/g),...a.match(/\D/g)].join``pero eso es 5 bytes más

Pruébalo aquí

f=
a=>a.replace(/\D/g,'')+a.replace(/\d/g,'')

a.innerHTML='<pre>'+
  ['A word can have any number of text like 433884,',
 'but all the numb89ers has to be moved left side',
 'but alph6abetical va9lues has to be pas46ted on right side.',
 'The text might con4tain chara29cters s2huffled like hlep or dfeintino or even',
 'meaningless words co43mbined togeth81er.'].map(b=>f(b)).join('<br>')+'</pre>'

<div id=a>

CJam, 9 9 13 16 bytes

qN/{{A,s-,}$}%N*

No hay f$...

Esta versión de 13 bytes casi funciona:

{l{A,s-,}$N}h

PowerShell v2 +, 55 bytes

$args[0]-split"`n"|%{($_-replace'\D')+($_-replace'\d')}

Debido a la necesidad de admitir entradas de varias líneas, tenemos que encapsular nuestras -replacedeclaraciones con un bucle y -spliten nuevas líneas. De lo contrario, básicamente equivalente a la solución de JavaScript .

Pyth - 11 bytes

No me gusta mi prueba de agrupación. Toma entrada como lista de líneas, dime si eso no está bien.

jms_.g}k`MT

Pruébelo en línea aquí .

Pyth, 16 15 bytes

1 byte gracias a @FryAmTheEggman .

jms+@J`MTd-dJ.z

Pruébalo en línea!

Entrada de muestra:

A word can have any number of text like 433884,
but all the numb89ers has to be moved left side 
but alph6abetical va9lues has to be pas46ted on right side.
The text might con4tain chara29cters s2huffled like hlep or dfeintino or even
meaningless1 words co43mbined togeth81er.

Salida de muestra:

433884A word can have any number of text like ,
89but all the numbers has to be moved left side 
6946but alphabetical values has to be pasted on right side.
4292The text might contain characters shuffled like hlep or dfeintino or even
14381meaningless words combined together.

Cómo funciona

jms+@J`MTd-dJ.z

 m           .z    for each line (d):
         d           yield d (the line)
     J                 assign J to
        T              [0,1,2,3,...,9]
      `M               with each number converted to string
    @                intersect with J
   +                 append:
          -dJ          filter d for characters not in J
  s                  convert to one string
j                  join by newline

Retina, 16 bytes

Estable tipo de burbuja.

%+`(\D)(\d)
$2$1

Entrada de muestra:

A word can have any number of text like 433884,
but all the numb89ers has to be moved left side 
but alph6abetical va9lues has to be pas46ted on right side.
The text might con4tain chara29cters s2huffled like hlep or dfeintino or even
meaningless1 words co43mbined togeth81er.

Salida de muestra:

433884A word can have any number of text like ,
89but all the numbers has to be moved left side 
6946but alphabetical values has to be pasted on right side.
4292The text might contain characters shuffled like hlep or dfeintino or even
14381meaningless words combined together.

Pruébalo en línea!

C #, 59 bytes

I=>Regex.Replace(I,"[^0-9]","")+Regex.Replace(I,@"\d+","");

Una función lambda simple de C # que usa regex.

Salida de muestra

433884A word can have any number of text like ,
89but all the numbers has to be moved left side
6946but alphabetical values has to be pasted on right side.
4292The text might contain characters shuffled like hlep or dfeintino or even
14381meaningless words combined together.

C # (LINQ), 110 bytes

s=>string.join("",s.Where(c=>"0123456789".Contains(c).Concat(s.SelectMany(c=>new[]{c}.Except("0123456789"))));

No es la solución más corta, de lejos, pero pensé que sería un buen uso de LINQ.

Factor 61

[ "\n"split [ [ digit? ] partition [ write ] bi@ nl ] each ]

Es un enfoque ingenuo.

"\n"splitdivide la cadena en la parte superior de la pila en líneas. Luego, para la eachlínea:

1. [ digit? ] partition divide cada línea en solo dígitos y no solo dígitos
2. [ write ] bi@genera ambos e nlimprime una nueva línea.

PD:

Como palabra, 90 bytes (71 si reemplaza el nombre largo de factorish con 1 letra):

: numbers-to-the-front ( s -- ) "\n"split [ [ digit? ] partition [ write ] bi@ nl ] each ;

Pyth, 14 bytes

FG.zo_:N"\d"0G

Pruébalo en línea!

Explicación:

FG             : For every G in ...
  .z           : the-list-where-lines-of-input-are-stored ...
               : (implicitly print)
    o        G : sorted G ...
     _N        : where, a negative key is given ...
       :"\d"0  : to the individual character if it is a digit

La lógica de la solución es la misma que en la respuesta de Lynn .

Java 8, 130 126 86 bytes

a->{for(String s:a)System.out.println(s.replaceAll("\\D","")+s.replaceAll("\\d",""));}

-4 bytes convirtiendo Java 7 a 8 y eliminando un
programa de conversión de caracteres no utilizados -40 bytes para funcionar y cambiar [^\\d]a\\D

Explicación:

Pruébalo aquí.

a->{                             // Method with String-array parameter and no return-type
  for(String s:a)                //  Loop over the array
    System.out.println(          //   Print with a trailing new-line:
      s.replaceAll("\\D","")     //    All digits,
      +s.replaceAll("\\d",""));  //    plus all non-digits

GNU Sed, 28

La puntuación incluye +1 para la -ropción de sed.

:
s/([^0-9])([0-9])/\2\1/
t

Cambia repetidamente un carácter no numérico seguido de un carácter numérico hasta que no se realicen más sustituciones.

Lamentablemente, las expresiones regulares sed no tienen \do \D, por lo que deben escribirse a mano.

Ideona

Octava, 37 32 bytes

@(s)disp([s(x=s>47&s<58),s(~x)])

ans('The text might con4tain chara29cters s2huffled like hlep or dfeintino or even')
4292The text might contain characters shuffled like hlep or dfeintino or even

Clojure, 113 bytes

(fn[s](map(fn[x](println(apply str(sort-by #(when-not(Character/isDigit %)1)x))))(clojure.string/split-lines s)))

Ordena los dígitos al comienzo de la línea.

Oracle SQL 11.2, 131 bytes

Las líneas en la cadena de entrada están separadas por '¤'. De esa manera, no es necesario crear una tabla para usar como entrada.

A word can have any number of text like 433884,¤but all the numb89ers has to be moved left side ¤but alph6abetical va9lues has to be pas46ted on right side.¤The text might con4tain chara29cters s2huffled like hlep or dfeintino or even¤meaningless1 words co43mbined togeth81er.

Consulta :

SELECT REGEXP_REPLACE(COLUMN_VALUE,'[^0-9]')||REGEXP_REPLACE(COLUMN_VALUE,'[0-9]')FROM XMLTABLE(('"'||REPLACE(:1,'¤','","')||'"'));

Sin golf

SELECT REGEXP_REPLACE(COLUMN_VALUE,'[^0-9]')||  -- Every number
       REGEXP_REPLACE(COLUMN_VALUE,'[0-9]')     -- Every character not a number   
FROM   XMLTABLE(('"'||REPLACE(:1,'¤','","')||'"'))  -- Split on ¤

APL, 28 caracteres

{⍵[⍋(~⍵∊⎕D)++\¯1⌽⍵=⎕UCS 13]}

Haskell, 60 bytes

import Data.List;g(n,l)=n++l;f=g.partition(`elem`['0'..'9'])

Uso

f "A word can have any number of text like 433884,"

Sed, 35 bytes

h
s/[0-9]//g
x
s/[^0-9]//g
G
s/\n//

Esto hace una copia de la línea, elimina los dígitos de una copia y las letras de la otra, antes de volver a combinarlos.

Bash, 42 bytes

read a&&echo "${a//[^0-9]}${a//[0-9]}"&&$0

¡Tenga en cuenta que esta implementación recursiva genera un nuevo proceso para cada línea de entrada!

Japt v2 , 14 12 bytes

-2 bytes gracias a ETHproductions

®o\d +Zr\d}R

Ejecutarlo

Julia 0.6 , 77 bytes

x->(l=r="";for c=x
c=='\n'?(println(l*r);l=r=""):'/'<c<':'?(l*=c):(r*=c)
end)

Función anónima que toma una cadena e imprime la salida. Recorre los personajes, los agrega a los buffers izquierdo lo derecho rhasta que encuentra una nueva línea, luego imprime y vacía los buffers. Muchas posibles construcciones útiles como sort,filter y la indexación lógica (indexación con una matriz de valores booleanos) no funcionan en cadenas.

Pruébalo en línea!

Vim, 30 pulsaciones de teclas

qr:%s/\v(\D+)(\d+)/\2\1/<Enter>@rq@r

Grabe una acción de búsqueda y reemplazo que mueva los dígitos a la izquierda de los que no sean dígitos. Llame a la macro de forma recursiva hasta que el patrón no se encuentre una excepción (cuando no haya más dígitos a la derecha de los que no sean dígitos).

C (gcc) , 106 bytes

g(s,x)char*s;{for(;*s;s++)isdigit(*s)^x&&putchar(*s);}f(s,n)char**s;{for(;n--;puts(""))g(*s,0),g(*s++,1);}

Pruébalo en línea!