Un paragraphe de texte est composé de chiffres et de lettres alphabétiques. Votre tâche consiste à séparer les chiffres du côté gauche et les lettres alphabétiques du côté droit dans le même ordre de chaque ligne.

Règles:

1. Les nombres sont des entiers simples; donc pas de point décimal, ni de signe négatif / positif.
2. Les nombres peuvent être contigus ou non, mais quel que soit le cas, ils doivent être poussés vers la gauche dans le même ordre.
3. Des nombres peuvent apparaître entre les mots.
4. Le texte ne contient que des lettres et des chiffres alphabétiques ASCII, ainsi que des espaces, des traits de soulignement, des virgules et des points.
5. Celui qui le fait avec un minimum de touches (comme les macros vim) ou le moins d'octets en cas de script est le gagnant.

Exemple de texte:

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.

Production attendue:

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.

Rétine , 14 octets

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

Essayez-le en ligne!

Explication

Ointroduit une étape de tri. %indique à Retina d'appliquer séparément la transformation à chaque ligne. $lui indique de trier les correspondances en fonction du résultat de la substitution spécifiée.

Le regex lui-même est celui \d|(.)qui correspond soit à un chiffre, soit à tout ce qui est capturé en groupe 1. Ceci est remplacé par $#1le nombre de captures de groupe 1. Autrement dit, la clé de tri des chiffres est0 et la clé de tri pour tout le reste est 1. Étant donné que le tri dans Retina est stable, cela déplace simplement les chiffres vers la gauche et tout le reste vers la droite.

05AB1E, 14 10 octets

Code:

|vyþyyþ-¶J

Explication:

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

Exemple d'entrée:

Un mot peut avoir n'importe quel nombre de texte comme 433884,
mais tous les numb89ers doivent être déplacés du côté gauche
mais les valeurs alphabétiques doivent être passées sur le côté droit.
Le texte pourrait contenir des chara29cters s2soufflés comme hlep ou dfeintino ou même des
mots dénués de sens co-combinés ensemble.

Exemple de sortie:

433884 Un mot peut avoir n'importe quel nombre de texte comme,
89 mais tous les nombres doivent être déplacés à gauche
6946 mais les valeurs alphabétiques doivent être collées à droite.
4292 Le texte peut contenir des caractères mélangés comme hlep ou dfeintino ou même des
mots sans signification combinés.

Essayez-le en ligne

Python 3, 64 octets

Trois solutions équivalentes! Je ne peux pas choisir.

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 octets

Code 16 octets + 1 commutateur

s/\d/!print$&/ge

Requiert -p.

Usage

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

Alternativement:

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

Requiert -n.

Usage

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

Hoon , 92 83 octets

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

++loredivise un cordon multi-lignes en un (list cord), le (trip +<)transforme en bande. ++skidsépare une liste en deux: un côté où la fonction renvoie oui, un côté où elle renvoie non. Notre fonction essaie d'analyser le caractère avec ++nud(numérique) et vérifie s'il analyse complètement, puis nous soudons les deux listes ensemble dans une bande.

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

`jt4Y2m&)hDT

Quitte avec une erreur (autorisée par défaut), produisant la sortie correcte.

Essayez-le en ligne!

Explication

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

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

V, est un langage de golf inachevé basé sur des cordes 2D. Bien qu'il soit inachevé, ce programme fonctionne à partir du commit 45 , qui a été publié la nuit dernière, ce qui en fait une réponse concurrente. (La plupart de mes réponses V précédentes n'étaient pas concurrentes.)

Notez que la nouvelle ligne de fin est nécessaire, bien que cela soit dû à un bogue.

Essayez-le en ligne!

Explication:

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

¨Ä©¨ä©/²± se développe dans le regex vim:

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

qui est un non-chiffre (\D)suivi d'un chiffre(\d) , et échangez-les.

Puisqu'il est rempli de caractères unicode grossiers, voici un hexdump réversible:

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

Javascript ES6, 40 octets

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

J'ai essayé plusieurs autres solutions, mais je n'ai pas pu le réduire.
Mon premier essai a été a=>[...a.match(/\d/g),...a.match(/\D/g)].join``mais c'est 5 octets de plus

Essayez-le ici

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 octets

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

Il n'y a pas f$...

Cette version de 13 octets fonctionne presque:

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

PowerShell v2 +, 55 octets

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

En raison de la nécessité de prendre en charge la saisie sur plusieurs lignes, nous devons encapsuler nos -replaceinstructions avec une boucle et -splitsur des sauts de ligne. Sinon, fondamentalement équivalent à la solution JavaScript .

Pyth - 11 octets

Je n'aime pas mon test de regroupement. Prend la saisie comme liste de lignes, dites-moi si ce n'est pas ok.

jms_.g}k`MT

Essayez-le en ligne ici .

Pyth, 16 15 octets

1 octet grâce à @FryAmTheEggman .

jms+@J`MTd-dJ.z

Essayez-le en ligne!

Exemple d'entrée:

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.

Exemple de sortie:

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.

Comment ça fonctionne

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

Rétine, 16 octets

Tri des bulles stable.

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

Exemple d'entrée:

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.

Exemple de sortie:

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.

Essayez-le en ligne!

C #, 59 octets

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

Une simple fonction lambda C # utilisant regex.

Exemple de sortie

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 octets

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

Pas la solution la plus courte, de loin, mais je pensais que ce serait une bonne utilisation de LINQ.

Facteur 61

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

C'est une approche naïve.

"\n"splitdivise la chaîne en haut de la pile en lignes. Ensuite, pour la eachligne:

1. [ digit? ] partition divise chaque ligne en chiffres uniquement et non en chiffres uniquement
2. [ write ] bi@sort les deux et nlimprime une nouvelle ligne.

PS:

En tant que mot 90 octets (71 si vous remplacez le-long-factorish-name par 1 lettre):

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

Pyth, 14 octets

FG.zo_:N"\d"0G

Essayez-le en ligne!

Explication:

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 logique de la solution est la même que dans la réponse de Lynn .

Java 8, 130 126 86 octets

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

-4 octets convertissant Java 7 en 8 et supprimant un caractère inutilisé
-40 octets programme de conversion pour fonctionner et passer [^\\d]à\\D

Explication:

Essayez-le ici.

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

Le score inclut +1 pour l' -roption de sed.

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

Bascule à plusieurs reprises un caractère non numérique suivi d'un caractère numérique jusqu'à ce qu'aucune substitution ne soit effectuée.

Malheureusement, les expressions rationnelles sed n'ont pas \dou \D, donc elles doivent être écrites à la main.

Ideone.

Octave, 37 32 octets

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

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

Trie les chiffres au début de la ligne.

Oracle SQL 11.2, 131 octets

Les lignes de la chaîne d'entrée sont séparées par '¤'. De cette façon, il n'est pas nécessaire de créer une table à utiliser comme entrée.

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.

Requete :

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

Non 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 caractères

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

Haskell, 60 octets

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

Usage

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

Sed, 35 octets

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

Cela crée une copie de la ligne, supprime les chiffres d'une copie et les lettres de l'autre, avant de les recombiner.

Bash, 42 octets

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

Soyez averti que cette implémentation récursive crée un nouveau processus pour chaque ligne d'entrée!

Japt v2 , 14 12 octets

-2 octets grâce à ETHproductions

®o\d +Zr\d}R

Exécuter

Julia 0,6 , 77 octets

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

Fonction anonyme prenant une chaîne et imprimant la sortie. Boucle les caractères, les ajoute aux tampons gauche lou droit rjusqu'à ce qu'il trouve une nouvelle ligne, puis il imprime et vide les tampons. Beaucoup de constructions utiles potentielles comme sort,filter et l'indexation logique (indexation avec un tableau de valeurs booléennes) ne fonctionnent pas sur les chaînes.

Essayez-le en ligne!

Vim, 30 frappes

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

Enregistrez une action de recherche et de remplacement qui déplace les chiffres vers la gauche des non-chiffres. Appelez la macro de manière récursive jusqu'à ce qu'une exception soit levée par le motif non trouvé (lorsqu'il n'y a plus de chiffres à droite des non-chiffres).

C (gcc) , 106 octets

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

Essayez-le en ligne!