Um parágrafo do texto possui números e letras alfabéticas misturadas. Sua tarefa é separar os números no lado esquerdo e as letras alfabéticas no lado direito na mesma ordem de cada linha.

Regras:

1. Os números são inteiros simples; portanto, sem ponto decimal e sem sinais negativos / positivos.
2. Os números podem ou não ser contíguos, mas seja qual for o caso, eles devem ser empurrados para o lado esquerdo na mesma ordem.
3. Os números podem ocorrer entre as palavras.
4. O texto contém apenas letras e números alfabéticos ASCII, juntamente com espaços, sublinhados, vírgulas e pontos.
5. Quem faz isso com o mínimo de pressionamentos de tecla (como macros do vim) ou com a menor quantidade de bytes no caso de scripts é o vencedor.

Texto de exemplo:

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.

Saída esperada:

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

Experimente online!

Explicação

Ointroduz um estágio de classificação. %diz à Retina para aplicar a transformação a cada linha separadamente. $diz para ordenar as correspondências pelo resultado da substituição especificada.

A regex em si é a \d|(.)que corresponde a um dígito ou a qualquer outra coisa capturada no grupo 1. Isso é substituído pelo $#1qual é o número de capturas do grupo 1. Ou seja, a chave de classificação para dígitos é 0e a chave de classificação para todo o resto é 1. Como a classificação na Retina é estável, isso simplesmente move os dígitos para a esquerda e todo o resto para a direita.

05AB1E, 14 10 bytes

Código:

|vyþyyþ-¶J

Explicação:

|                 # 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

Exemplo de entrada:

Uma palavra pode ter qualquer número de texto como 433884,
mas todos os números devem ser movidos para o lado esquerdo,
mas os valores alfabéticos devem ser passados ​​para o lado direito.
O texto pode conter caracteres estragados como hlep ou dfeintino ou mesmo
palavras sem sentido, combinadas entre si.

Saída de exemplo:

433884Uma palavra pode ter qualquer número de texto, como
89 , mas todos os números devem ser movidos para o lado esquerdo
6946 , mas os valores alfabéticos devem ser colados no lado direito.
O texto pode conter caracteres embaralhados como hlep ou dfeintino ou até
4381 palavras sem significado combinadas.

Experimente online

Python 3, 64 bytes

Três soluções equivalentes! Eu não posso escolher.

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 opção

s/\d/!print$&/ge

Requer -p.

Uso

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

Alternativamente:

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

Requer -n.

Uso

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

Hoon , 92 83 bytes

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

++loredivide um cabo de várias linhas em um (list cord)e o (trip +<)transforma em fita. ++skidsepara uma lista em dois: um lado em que a função retorna sim, um lado em que retorna não. Nossa função tenta analisar o caractere com ++nud(numérico) e verifica se ele analisa completamente, e depois juntamos as duas listas novamente em uma fita.

> %.
  '''
  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

Sai com um erro (permitido por padrão), produzindo a saída correta.

Experimente online!

Explicação

`          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, é uma linguagem de golfe inacabada, baseada em cordas 2D. Embora esteja inacabado, este programa funciona a partir do commit 45 , que foi publicado ontem à noite, tornando-o uma resposta competitiva. (A maioria das minhas respostas V anteriores não era competitiva.)

Observe que a nova linha à direita é necessária, embora isso ocorra devido a um erro.

Experimente online!

Explicação:

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

¨Ä©¨ä©/²± expande para o vim regex:

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

que é um não dígito (\D)seguido por um dígito (\d)e troque-os.

Como isso é preenchido com caracteres unicode brutos, aqui está um hexdump reversível:

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

Javascript ES6, 40 bytes

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

Tentei várias outras soluções, mas não conseguiu reduzi-lo a isso.
Minha primeira tentativa foi a=>[...a.match(/\d/g),...a.match(/\D/g)].join``mas são 5 bytes mais longos

Experimente aqui

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 13 16 bytes

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

Não tem f$...

Esta versão de 13 bytes quase funciona:

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

PowerShell v2 +, 55 bytes

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

Devido à necessidade de oferecer suporte a entrada de várias linhas, precisamos encapsular nossas -replacedeclarações com um loop e -splitem novas linhas. Caso contrário, basicamente equivalente à solução JavaScript .

Pitão - 11 bytes

Não gostei do meu teste de agrupamento. Aceita entrada como lista de linhas, me diga se não está ok.

jms_.g}k`MT

Experimente online aqui .

Pyth, 16 15 bytes

1 byte graças a @FryAmTheEggman .

jms+@J`MTd-dJ.z

Experimente online!

Entrada de amostra:

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.

Saída de amostra:

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.

Como 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

Classificação de bolha estável.

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

Entrada de amostra:

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.

Saída de amostra:

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.

Experimente online!

C #, 59 bytes

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

Uma função lambda C # simples usando regex.

Saída de amostra

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"))));

Não é a solução mais curta, de longe, mas achei que esse seria um bom uso do LINQ.

Fator 61

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

É uma abordagem ingênua.

"\n"splitdivide a string no topo da pilha em linhas. Então, para a eachlinha:

1. [ digit? ] partition divide cada linha em somente dígitos e não somente dígitos
2. [ write ] bi@produz ambos e nlimprime uma nova linha.

PS:

Como uma palavra 90 bytes (71 se você substituir o nome longo do fator por uma letra):

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

Pitão, 14 bytes

FG.zo_:N"\d"0G

Experimente online!

Explicação:

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

A lógica da solução é a mesma da resposta de Lynn .

Java 8, 130 126 86 bytes

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

-4 bytes convertendo Java 7 a 8 e removendo um programa não utilizado de
conversão de caracteres -40 bytes para funcionar e alterando [^\\d]para\\D

Explicação:

Experimente aqui.

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

A pontuação inclui +1 para a -ropção sed.

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

Alterna repetidamente um caractere não numérico seguido de um caractere numérico até que não sejam feitas mais substituições.

Infelizmente, os regexes sed não têm \dou \D, portanto, esses devem ser redigidos à mão.

Ideone.

Oitava, 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)))

Classifica os dígitos no início da linha.

Oracle SQL 11.2, 131 bytes

As linhas na sequência de entrada são separadas por '¤'. Dessa forma, não é necessário criar uma tabela 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.

Inquerir :

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

Sem golfe

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//

Isso faz uma cópia da linha, remove os dígitos de uma cópia e as letras da outra, antes de recombiná-las.

Bash, 42 bytes

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

Esteja avisado de que essa implementação recursiva bifurca um novo processo para cada linha de entrada!

Japonês v2 , 14 12 bytes

-2 bytes graças a ETHproductions

®o\d +Zr\d}R

Executá-lo

Julia 0,6 , 77 bytes

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

Função anônima pegando uma string e imprimindo a saída. Faz um loop sobre os caracteres, adicionando-os aos buffers esquerdo lou direito raté encontrar uma nova linha, depois imprime e esvazia os buffers. Muitas construções úteis em potencial sort, como ,filter e a indexação lógica (indexação com uma matriz de valores booleanos) não funcionam em Strings.

Experimente online!

Vim, 30 pressionamentos de tecla

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

Grave uma pesquisa e substitua a ação que move os dígitos à esquerda dos que não são dígitos. Chame a macro recursivamente até que uma exceção seja lançada pelo padrão não encontrado (quando não houver mais dígitos à direita de nenhum outro dígito).

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);}

Experimente online!