Un paragrafo di testo ha numeri e lettere alfabetiche miste. Il tuo compito è quello di separare i numeri sul lato sinistro e le lettere alfabetiche sul lato destro nello stesso ordine di ogni riga.

Regole:

1. I numeri sono numeri interi semplici; quindi nessun punto decimale e nessun segno negativo / positivo.
2. I numeri possono o meno essere contigui, ma qualunque sia il caso, devono essere spinti a sinistra nello stesso ordine.
3. I numeri possono verificarsi tra le parole.
4. Il testo contiene solo lettere e numeri alfabetici ASCII, insieme a spazi, trattini bassi, virgole e punti.
5. Colui che lo fa con un numero minimo di tasti (come le macro di VIM) o il minor numero di byte in caso di script è il vincitore.

Testo di esempio:

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.

Uscita prevista:

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 byte

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

Provalo online!

Spiegazione

Ointroduce una fase di smistamento. %dice a Retina di applicare la trasformazione su ciascuna riga separatamente.$gli dice di ordinare le partite in base al risultato della sostituzione specificata.

La regex stessa è \d|(.)che corrisponde a una cifra o qualsiasi altra cosa che viene catturata in gruppo 1. Questo è sostituito con $#1quale è il numero di acquisizioni di gruppo 1. Cioè, la chiave di ordinamento per le cifre è 0e la chiave di ordinamento per tutto il resto 1. Poiché l'ordinamento in Retina è stabile, questo sposta semplicemente le cifre a sinistra e tutto il resto a destra.

05AB1E, 14 10 byte

Codice:

|vyþyyþ-¶J

Spiegazione:

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

Esempio di input:

Una parola può avere un numero qualsiasi di testo come 433884,
ma tutti i numb89er devono essere spostati sul lato sinistro,
ma i valori matematici alph6 devono essere passati sul lato destro.
Il testo potrebbe contenere chara29cters s2huffled come hlep o dfeintino o anche
parole insignificanti che si confondono insieme.

Esempio di output:

433884 Una parola può avere qualsiasi numero di testo come,
89 ma tutti i numeri devono essere spostati sul lato sinistro
6946 ma i valori alfabetici devono essere incollati sul lato destro.
4292 Il testo potrebbe contenere caratteri mescolati come hlep o dfeintino o addirittura
4381 parole senza parole combinate insieme.

Provalo online

Python 3, 64 byte

Tre soluzioni equivalenti! Non posso scegliere.

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 byte

Codice 16 byte + 1 interruttore

s/\d/!print$&/ge

Richiede -p.

uso

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

In alternativa:

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

Richiede -n.

uso

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

Hoon , 92 83 byte

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

++loredivide un cavo multilinea in a (list cord), lo (trip +<)trasforma in un nastro. ++skidsepara un elenco in due: un lato in cui la funzione restituisce sì, un lato in cui restituisce no. La nostra funzione tenta di analizzare il carattere con ++nud(numerico) e controlla se analizza completamente, quindi saldiamo nuovamente le due liste in un nastro.

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

`jt4Y2m&)hDT

Esce con un errore (consentito per impostazione predefinita), producendo l'output corretto.

Provalo online!

Spiegazione

`          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 byte

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

V, è un linguaggio di golf non finito, basato su stringhe 2D. Sebbene sia incompiuto, questo programma funziona a partire dal commit 45 , che è stato pubblicato ieri sera, rendendolo una risposta concorrenziale. (La maggior parte delle mie precedenti risposte V erano non concorrenti.)

Nota, la nuova riga finale è necessaria, sebbene ciò sia dovuto a un bug.

Provalo online!

Spiegazione:

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

¨Ä©¨ä©/²± si espande nel regex di vim:

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

che è una non cifra (\D)seguita da una cifra (\d)e scambiarli.

Poiché questo è pieno di caratteri unicode grossolani, ecco un hexdump reversibile:

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

Javascript ES6, 40 byte

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

Ho provato diverse altre soluzioni, ma non sono riuscito a rimpicciolirlo.
Il mio primo tentativo è statoa=>[...a.match(/\d/g),...a.match(/\D/g)].join`` ma sono 5 byte in più

Provalo qui

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 byte

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

Non c'è f$...

Questa versione da 13 byte funziona quasi:

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

PowerShell v2 +, 55 byte

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

A causa della necessità di supportare l'input multilinea, dobbiamo incapsulare le nostre -replacedichiarazioni con un ciclo e -splitsu nuove righe. Altrimenti sostanzialmente equivalente alla soluzione JavaScript .

Pyth - 11 byte

Non mi piace il mio test di raggruppamento. Accetta input come elenco di righe, dimmi se non va bene.

jms_.g}k`MT

Provalo online qui .

Pyth, 16 15 byte

1 byte grazie a @FryAmTheEggman .

jms+@J`MTd-dJ.z

Provalo online!

Input di esempio:

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.

Uscita campione:

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.

Come funziona

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 byte

Ordinamento delle bolle stabile.

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

Input di esempio:

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.

Uscita campione:

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.

Provalo online!

C #, 59 byte

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

Una semplice funzione lambda C # usando regex.

Uscita campione

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 byte

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

Di gran lunga non la soluzione più breve, ma ho pensato che sarebbe stato un buon uso di LINQ.

Fattore 61

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

È un approccio ingenuo.

"\n"splitdivide la stringa in cima alla pila in linee. Quindi, per la eachriga:

1. [ digit? ] partition divide ogni riga in solo cifre e non solo cifre
2. [ write ] bi@genera entrambi e nlstampa una nuova riga.

PS:

Come una parola di 90 byte (71 se si sostituisce il nome-fattore-lungo con 1 lettera):

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

Pyth, 14 byte

FG.zo_:N"\d"0G

Provalo online!

Spiegazione:

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 logica della soluzione è la stessa della risposta di Lynn .

Java 8, 130 126 86 byte

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

-4 byte convertendo Java 7 in 8 e rimuovendo un carattere inutilizzato
-40 byte convertendo il programma in funzione e passando [^\\d]a\\D

Spiegazione:

Provalo qui.

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

Il punteggio include +1 per l' -ropzione di sed.

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

Commuta ripetutamente un carattere non numerico seguito da un carattere numerico fino a quando non vengono più sostituite.

Purtroppo le regex sed non ne hanno \do \D, quindi devono essere scritte a lungo.

Ideone.

Ottava, 37 32 byte

@(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 byte

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

Ordina le cifre all'inizio della riga.

Oracle SQL 11.2, 131 byte

Le righe nella stringa di input sono separate da '¤'. In questo modo non è necessario creare una tabella da utilizzare come input.

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.

Query:

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

Un-golfed

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 caratteri

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

Haskell, 60 byte

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 byte

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

Questo crea una copia della linea, rimuove le cifre da una copia e le lettere dall'altra, prima di ricombinarle.

Bash, 42 byte

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

Tieni presente che questa implementazione ricorsiva prevede un nuovo processo per ogni riga di input!

Japt v2 , 14 12 byte

-2 byte grazie a ETHproductions

®o\d +Zr\d}R

Eseguirlo

Julia 0.6 , 77 byte

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

Funzione anonima che accetta una stringa e stampa l'output. Passa sopra i personaggi, aggiungendoli ai buffer sinistro lo destro rfinché non trova una nuova riga, quindi stampa e svuota i buffer. Sacco di potenziali costrutti utili come sort, filtere indicizzazione logica (indicizzazione con una serie di valori booleani) non funzionano ad Archi.

Provalo online!

Vim, 30 sequenze di tasti

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

Registra una ricerca e sostituisci l'azione che sposta le cifre a sinistra delle non cifre. Chiamare la macro in modo ricorsivo fino a quando non viene generata un'eccezione dal modello che non viene trovato (quando non ci sono più cifre a destra delle non cifre).

C (gcc) , 106 byte

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

Provalo online!