Inverser les courses positives


22

Contribution

Votre entrée est une liste de nombres à un chiffre dans n'importe quel format raisonnable, y compris une chaîne de chiffres. L'entrée ne sera pas vide.

Sortie

Votre sortie doit être la liste d'entrée, mais avec chaque série maximale de chiffres différents de zéro inversée.

Exemple

Considérez l'entrée

95883007414830
<--->  <---->

où les courses non nulles ont été marquées avec des flèches. En inversant chacune de ces exécutions, nous obtenons la sortie

38859003841470

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Ce défi est lié, mais beaucoup plus complexe, car il inclut un traitement de chaîne supplémentaire.

Cas de test

4 -> 4
00 -> 00
123 -> 321
0010 -> 0010
12000345 -> 21000543
18161604 -> 61618104
95883007414830 -> 38859003841470
010230456078912 -> 010320654021987
357509902003550 -> 575309902005530
2492882377675046 -> 5767732882942064
03026302053000357099 -> 03036202035000753099

Classement

Voici un extrait de pile pour générer un classement et une liste des gagnants par langue. Pour vous assurer que votre réponse s'affiche, commencez-la par un en-tête du formulaire

## Language, N bytes

Vous pouvez conserver les anciens scores dans l'en-tête en utilisant les balises barrées: <s>57</s>apparaîtra comme 57 .

Réponses:



8

IPOS , 5 octets

'0!r%

%divise la chaîne d'entrée sur des zéros, applique la commande r(inverse) à chaque sous-chaîne et joint le résultat sur des zéros.


7

Rétine , 15 octets

S`0
O%^$`.

¶
0

Essayez-le en ligne! (Légèrement modifié pour exécuter tous les cas de test en même temps.)

Explication

S`0

Répartissez l'entrée autour de 0s, c'est-à-dire mettez chaque série (éventuellement vide) de chiffres non nuls sur sa propre ligne.

O%^$`.

Cela inverse chaque ligne, en:

  • Appliquer la scène à chaque ligne individuellement avec %.
  • Faire correspondre chaque caractère individuellement avec ..
  • Le trier par le résultat de la substitution ( $) avec la chaîne vide (la deuxième ligne vide). C'est-à-dire qu'il ne trie pas du tout, car toutes les valeurs de tri sont identiques.
  • Inverse ensuite l'ordre des caractères triés.

Finalement:

¶
0

Remettez les sauts de ligne en 0s.


5

05AB1E , 6 octets

Code:

0¡€R0ý

Explication:

0¡      # Split on zeros
  €R    # For each item in the array, reverse it
    0ý  # Join by zeros

Utilise l' encodage CP-1252 . Essayez-le en ligne! .


5

Julia, 30 octets

s->replace(s,r"[^0]+",reverse)

Il s'agit d'une fonction anonyme qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, affectez-le à une variable.

La replacefonction offre la possibilité de remplacer les correspondances d'une expression régulière par le résultat d'une fonction appliquée à chaque correspondance. Dans ce cas, nous pouvons faire en sorte que les non-zéros utilisent [^0]+et remplacent ces exécutions par le résultat de la reversefonction appliquée au texte correspondant.

Vérifiez tous les cas de test en ligne!


4

Rétine, 25 24

O^$#`[^0](?=(.*?0)*)
$#1

Essayez-le en ligne

1 octet enregistré grâce à Martin!

Triez les chiffres non nuls par le nombre de zéros qui suivent le chiffre, dans l'ordre inverse.

Voir la solution de Martin pour une utilisation intelligente du mode par ligne pour obtenir un programme plus court!


4

Jolf, 8 octets

RΜGi0λ_0

Essayez-le ici!

Explication

RΜGi0λ_0
  Gi0     split input on zeroes
 Μ   λ_   map over reversal as a lambda
R      0  join by zeroes

L'explication du code ressemble à un lambda si vous plissez les yeux.

Une réponse équivalente à 8 octets:

RΜGi0΅O0

Même chose, mais il utilise ΅O(chaîne miroir lambda) à la place.


Je dirais que ça ressemble plus à du texte dans une forme amusante quand je plisse les yeux. Je devrais peut-être ranger ce télescope.
chat

1
@cat Non, non, garde-le, mais regarde le lambda quand tu le fais.
Conor O'Brien


3

Python, 58 50 octets

lambda x:"0".join([n[::-1] for n in x.split("0")])

Prend une chaîne x et se divise sur les zéros et inverse chaque élément de la division et ajoute un zéro et renvoie le dernier moins ce zéro.


1
Bienvenue sur PPCG :) Vous devriez pouvoir faire "0".joinpuis supprimer l'ajout et la tranche.
FryAmTheEggman

@FryAmTheEggman merci pour l'astuce
1232

Pas de problème :) Vous pouvez également supprimer l'espace entre ]et for. Vous pouvez consulter nos conseils page de pour plus de pointeurs, si vous le souhaitez.
FryAmTheEggman

7
lambda x:"0".join(n[::-1]for n in x.split("0"))
orlp

3

Mathematica, 30 octets

Join@@Reverse/@#~SplitBy~Sign&

par exemple Join@@Reverse/@#~SplitBy~Sign&[{1,2,3,0,0,5,9,0}]={3, 2, 1, 0, 0, 9, 5, 0}


2

PowerShell v2 +, 45 octets

($args-split0|%{-join$_[$_.length..0]})-join0

Abuser du casting implicite comme s'il n'y avait pas de lendemain. Il est probable qu'il ne puisse pas être beaucoup plus court, car il n'y a pas de fonction intégrée pour l'inverse plus courte que cette astuce d'indexation.

Explication

Un exemple de la façon dont cela fonctionne - supposons 123045était l'entrée $args. Après l' -splitactivation 0, le pipeline contiendrait un tableau (123,45). La première boucle avec |%{...}a l'élément courant $_égal à 123, qui est ensuite implicitement converti en chaîne, puis inversé avec l' []indexation. Cela en fait ('3','2','1')un tableau de caractères. La boucle -joinremet cela en chaîne "321"et le laisse sur le pipeline. L'itération de boucle suivante (dernière) inverse l'entrée "54". Alors maintenant , notre pipeline est "321", "54". C'est encapsulé en parens ()donc il est reformé en un tableau et ré- -joinédité avec des zéros pour produire la chaîne de sortie résultante"321054". Cela reste sur le pipeline et la sortie vers la console est implicite.

S'il y a des zéros ultérieurs dans l'entrée d'origine, le tableau serait rempli d'éléments nuls, donc il y a le nombre correct de zéros sur la sortie. Par exemple, se 1230045-split0transforme en (123,,45)et les choses continuent comme ci-dessus.



2

Facteur, 35 octets

Battre Pyfon et Clojure, booyah!

[ "0"split [ reverse ] map "0"join ]

Cette fonction anonyme est une traduction littérale de cette réponse Python .

C'est assez simple, il suffit de diviser la chaîne sur des zéros, d'inverser chaque élément du tableau résultant et de joindre tous les éléments (y compris les chaînes de longueur nulle) avec "0".

Voici un exemple de son exécution sur tous les cas de test:

IN: scratchpad auto-use {
        "4"
        "00"
        "123"
        "0010"
        "12000345"
        "18161604"
        "95883007414830"
        "010230456078912"
        "357509902003550"
        "2492882377675046"
        "03026302053000357099"
        }
        [ 
          "0" split [ reverse ] map "0" join
        ]
        map .

{
    "4"
    "00"
    "321"
    "0010"
    "21000543"
    "61618104"
    "38859003841470"
    "010320654021987"
    "575309902005530"
    "5767732882942064"
    "03036202035000753099"
}

"00120"-> { "" "" "12" "" }-> { "" "" "21" "" }->"00210"


2

Haskell, 45 octets

r%(0:t)=r++0:[]%t
r%(h:t)=(h:r)%t
r%_=r
([]%)

Accumule récursivement le morceau inversé jusqu'à présent r, l'ajoutant quand a 0est atteint. Lorsque la chaîne restante est vide, elle se décharge également r.

Les deux premiers répètent du code, mais je n'ai pas trouvé de moyen plus court de les combiner (45 et 47 octets):

r%(h:t)|h<1=r++h:[]%t|1>0=(h:r)%t
r%_=r
([]%)

r%l|0:t<-l=r++0:[]%t|h:t<-l=(h:r)%t
r%_=r
([]%)

Je pense que vous avez besoin d'une autre paire de parenthèses dans la ligne n ° 2:r%(h:t)=(h:r)%t
nimi

1

Pyke, 8 octets

\0cm_\0J

Explication:

\0c      -   input().split("0")
   m_    -  map(reversed, ^)
     \0J - "0".join(^)

Essayez-le ici!


1

JavaScript (ES6), 50 49 octets

Version chaîne:

s=>s.replace(/[^0]+/g,r=>[...r].reverse().join``)

Un octet enregistré grâce à @Kevin Lau!

Version de la baie (60 octets):

a=>a.map((n,i)=>n?a[z-i+[...a,0].indexOf(0,i)]:(z=i,0),z=-1)

1

J, 20 18 octets

0}:@;@(<@|.;.1)@,]

Merci à Zgarb pour votre aide! Prend une liste séparée par des espaces comme argument de droite.

-2 octets grâce à Zgarb!


1

Clojure / ClojureScript, 44 caractères

#(flatten(map reverse(partition-by pos? %)))

Même solution que les autres, juste plus verbeuse grâce aux longs noms de fonction. N'allait pas le poster à cause de cela, mais il bat d'autres réponses, alors pourquoi pas?

Fonctionne sur tout type de séquence. Dans ClojureScript, cela fonctionne également sur les chaînes, car les chaînes peuvent être traitées comme des listes de caractères, qui ne sont en réalité que des chaînes de 1 longueur, qui contraignent les nombres à des choses comme pos?.


1

Haskell, 46 octets

import Data.Lists
(reverse=<<).split(oneOf"0")

Exemple d'utilisation: (reverse=<<).split(oneOf"0") $ "0123004500678090"-> "0321005400876090".

Malheureusement, la splitfonction nécessite une importation coûteuse. Divisez la liste d'entrée à chaque 0, par exemple split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], inversez chaque bloc et concaténez en une seule chaîne.


1

F #, 103 octets

let f x=x="";x.Split '0'|>Array.map(fun s->System.String(s|>Seq.toArray|>Array.rev))|>String.concat "0"

1

Java, 179 octets (avec importation)

import java.util.*;static void r(String s){StringJoiner x= new StringJoiner("0");for(String a:s.split("0",s.length())){x.add(new StringBuilder(a).reverse());}System.out.print(x);}

Prend une entrée de chaîne et divise les caractères par zéro, puis les ajoute en appelant la méthode add sur la classe StringJoiner.


1

Oracle SQL 11.2, 131 123 octets

Abus des fonctions XML.

SELECT LISTAGG(REVERSE(COLUMN_VALUE||''))WITHIN GROUP(ORDER BY rownum)FROM XMLTABLE(('"'||REPLACE(:1,'0','","0","')||'"'));

1

Perl, 22 octets

Y compris +1 pour l' -poption:

s/[^0]+/reverse$&/eg

C'est une substitution assez banale - désolé d'être si ennuyeux. Notez que si votre entrée se termine par un saut de ligne (par exemple, en utilisant perl -pe 's/[^0]+/reverse$&/eg' <<<21000543Bash), il attrapera le saut de ligne avec les chiffres - utilisez echo -nou printfpour éviter cela. Alternativement, pour un coût d'un octet supplémentaire, remplacez la classe de caractères par [1-9], et vous pouvez fournir de nombreuses entrées, une par ligne.


1

C, 105 octets

#define x(o)for(p=s;*s&&'0'o*s;++s);for(r=s;r-->p;putchar(*r));
f(s,p,r)char*s,*p,*r;{x(^)x(==)*s&&f(s);}

Appel f avec la liste des chiffres sous forme de chaîne terminée par zéro et il affichera la sortie correcte.

Non golfé et expliqué:

f(s,p,r)
char*s,*p,*r; // K&R style to avoid repeating `char`
{

    // x(^)x(==) expands to...

    // Find the next zero digit
    for(p = s; *s && '0' ^ *s; ++s)
        ;

    // Print that run backwards
    for(r = s; r-- > p; putchar(*r))
        ;

    // Find the next non-zero digit
    for(p = s; *s && '0' == *s; ++s)
        ;

    // Print that run backwards (no difference, it's all zeros)
    for(r = s; r-- > p; putchar(*r))
        ;

    // If there's more string, recurse
    *s && f(s);
}

Voir en direct sur Coliru


0

Perl 5, 52 octets

Un sous-programme:

{$_=pop;y/0/ /;map$i.=reverse,split/\b/;$i=~y/ /0/r}

-ane fonctionne pas (au moins dans Strawberry) lorsque la chaîne d'entrée se termine 0, car split/\b/inclut le $/avec le 0.
msh210

0

En fait, 22 octets

k"a%sa"%'0@s♂R'0j#pXdX

Cela m'a fait remarquer qu'il y a un bug dans la commande split - elle ne conserve pas les divisions vides. Pour contourner ce problème, j'entoure la chaîne d'entrée de as avant de faire le fractionnement, l'inverse et la jointure, puis je supprime le as à la fin. L'entrée est considérée comme une chaîne, la sortie est une liste de chaînes à un seul caractère.

Essayez-le en ligne

Explication:

k"a%sa"%'0@s♂R'0j#pXdX
k"a%sa"%                surround input with "a" characters
        '0@s            split on 0
            ♂R          reverse each piece
              '0j       join on 0
                 #pXdX  listify, remove first and last element (the "a"s)

0

C #, 131 octets ##

solution imparfaite!

string j(string i){foreach(var s in i.Split('0'))if(s!="")i=i.Replace(s,new string(s.ToCharArray().Reverse().ToArray()));return i;}

non golfé:

string j(string input)
    {

        string[] a = input.Split('0');

        foreach (string s in a)
        {
            if (s!="")
            input=input.Replace(s, new string(s.ToCharArray().Reverse().ToArray()));
        }

        return input;
    }

1
Je crois que cette méthode a un bogue lorsqu'une chaîne à inverser est un sous-ensemble d'une autre. Si donné l'entrée 01201230, cela reviendrait 02102130. En effet, la méthode String.Replace remplace toutes les occurrences de la première chaîne par la seconde. Ce bogue serait également provoqué si un motif apparaît lorsqu'il est inversé ( 0120210reviendrait 0120120).
Xynariz

Je n'ai même pas pensé à ça ..
downrep_nation

0

C #, 133 octets


Golfé

String m(String s){for(int i=0,p=i;i<s.Length;i++){if(s[i]=='0'){p=i+1;}else{s=s.Insert(p,s[i].ToString()).Remove(i+1,1);}}return s;}

Non golfé

String m( String s ) {
    // i = Index on the String
    // p = Pointer of the last '0' found
    for (int i = 0, p = i; i < s.Length; i++) {
        if (s[ i ] == '0') {
            // Move the 'p' pointer to the index after this '0'
            p = i + 1;
        } else {
            // Insert the Char at the Index location to the Pointer location 
            //    and remove the one at the Index Location + 1,
            //    since the String was incremented by one char due to the 'Insert()'.
            s = s.Insert( p, s[ i ].ToString() )
                 .Remove( i + 1, 1 );
        }
    }

    return s;
}

Code complet

using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            List<String> ls = new List<String>() {
                "4",
                "00",
                "123",
                "0010",
                "12000345",
                "18161604",
                "95883007414830",
                "010230456078912",
                "357509902003550",
                "2492882377675046",
                "03026302053000357099"
            };

            foreach (String s in ls) {
                String f = m( s );

                Console.WriteLine( String.Format( "{0,30}", s.Replace( "0", "0 " ) ) );
                Console.WriteLine( String.Format( "{0,30}", f.Replace( "0", "0 " ) ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            for (Int32 i = 0, p = i; i < s.Length; i++) {
                if (s[ i ] == '0') {
                    p = i + 1;
                } else {
                    s = s.Insert( p, s[ i ].ToString() ).Remove( i + 1, 1 );
                }
            }

            return s;
        }
    }
}

Je viens de remarquer maintenant que @downrep_nation avait déjà posté ici une solution pour C #, qui bat mon code de 2 octets ... (ça peut être plus ....)
auhmaan

0

Java, 126

a->{String r="",t[]=a.split("0");for(String s:t){r+=new StringBuilder(s).reverse()+"0";}return r.substring(0, r.length()-1);}

Si vous déclarez la svariable à l'avant avec ret t[], pouvez-vous omettre la déclaration de type de sdans la boucle for?
Cyoce

Non, je l'ai vérifié, les boucles améliorées ont besoin d'une variable nouvellement déclarée.
Espérons utile

hein. C'est bizarre.
Eh

0

Clojure, 37 octets

#(mapcat reverse(partition-by #{0}%))

Utilise à la #{0}place de pos?(enregistrez 1 octet en concaténant avec %) et utilisez à la mapcatplace de (flatten(map. Encore plus long que Factor .

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.