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 .

/* Configuration */

var QUESTION_ID = 78510; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 32014; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (! /<a/.test(lang)) lang = '<i>' + lang + '</i>';
    lang = jQuery(lang).text().toLowerCase();

    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link, uniq: lang};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.uniq > b.uniq) return 1;
    if (a.uniq < b.uniq) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=617d0685f6f3">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>

Pyth, 8

j0_Mcz\0

Séparez les zéros, inversez et rejoignez les zéros.

Suite de tests

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.

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.

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! .

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!

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!

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.

Rubis, 29 octets

->x{x.gsub /[^0]*/,&:reverse}

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.

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}

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.

Gelée, 5 octets

ṣ0Uj0

Essayez-le en ligne!

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"

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
([]%)

Pyke, 8 octets

\0cm_\0J

Explication:

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

Essayez-le ici!

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)

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!

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?.

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.

F #, 103 octets

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

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.

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

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.

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

Perl 5, 52 octets

Un sous-programme:

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

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)

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

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

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

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 .