Entrada

Sua entrada é uma lista de números de um dígito em qualquer formato razoável, incluindo uma sequência de dígitos. A entrada não estará vazia.

Saída

Sua saída deve ser a lista de entrada, mas com cada execução máxima de dígitos diferentes de zero sendo revertida.

Exemplo

Considere a entrada

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

onde as execuções diferentes de zero foram marcadas com setas. Invertendo cada uma dessas execuções, obtemos a saída

38859003841470

Regras e pontuação

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Esse desafio está relacionado, mas muito mais complexo, pois inclui processamento adicional de cadeias.

Casos de teste

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

Entre os melhores

Aqui está um snippet de pilha para gerar um placar e uma lista de vencedores por idioma. Para garantir que sua resposta seja exibida, inicie-a com um cabeçalho do formulário

## Language, N bytes

Você pode manter pontuações antigas no cabeçalho usando as tags tachado: <s>57</s>aparecerá como 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>

Pitão, 8

j0_Mcz\0

Dividir em zeros, inverter e juntar novamente em zeros.

Suíte de teste

IPOS , 5 bytes

'0!r%

%divide a string de entrada em zeros, aplica o comando r(reverso) a cada substring e junta o resultado novamente em zeros.

Retina , 15 bytes

S`0
O%^$`.

¶
0

Experimente online! (Ligeiramente modificado para executar todos os casos de teste de uma vez.)

Explicação

S`0

Divida a entrada em torno de 0s, ou seja, coloque cada execução (possivelmente vazia) de dígitos diferentes de zero em sua própria linha.

O%^$`.

Isso inverte cada linha, por:

• Aplicando o palco a cada linha individualmente com %.
• Combinando cada caractere individualmente com ..
• Classificando-o pelo resultado da substituição ( $) pela sequência vazia (a segunda linha vazia). Ou seja, não classifica nada, uma vez que todos os valores de classificação são idênticos.
• Em seguida, inverte a ordem dos caracteres classificados.

Finalmente:

¶
0

Transforme os feeds de linha novamente em 0s.

05AB1E , 6 bytes

Código:

0¡€R0ý

Explicação:

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

Usa a codificação CP-1252 . Experimente online! .

Julia, 30 bytes

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

Esta é uma função anônima que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.

A replacefunção fornece a capacidade de substituir correspondências de uma expressão regular pelo resultado de uma função aplicada a cada correspondência. Nesse caso, podemos obter nonzeros usando [^0]+e substituindo essas execuções pelo resultado da reversefunção aplicada ao texto correspondente.

Verifique todos os casos de teste online!

Retina, 25 24

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

Experimente online

Guardado 1 byte graças a Martin!

Classifique os dígitos diferentes de zero pelo número de zeros que seguem o dígito, na ordem inversa.

Veja a solução de Martin para um uso inteligente do modo por linha para obter um programa mais curto!

Jolf, 8 bytes

RΜGi0λ_0

Experimente aqui!

Explicação

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

A explicação do código parece uma lambda se você for apertar os olhos.

Uma resposta equivalente de 8 bytes:

RΜGi0΅O0

A mesma coisa, mas usa ΅O(espelho de cadeia lambda).

Ruby, 29 bytes

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

Python, 58 50 bytes

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

Pega uma string x e ​​divide os zeros e inverte cada elemento na divisão e adiciona um zero e retorna o último menos esse zero.

Mathematica, 30 bytes

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

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

PowerShell v2 +, 45 bytes

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

Abusando do elenco implícito como se não houvesse amanhã. Provavelmente não pode ficar muito mais curto, pois não há um mecanismo de reversão mais curto que esse truque de indexação.

Explicação

Um exemplo de como isso funciona - suponha que 123045foi a entrada $args. Após a -splitativação 0, o pipeline conteria uma matriz (123,45). O primeiro loop com |%{...}tem o elemento atual $_igual a 123, que é convertido implicitamente como uma string e depois revertido com a []indexação. Isso faz com que ('3','2','1')seja um array de caracteres. O loop -joincoloca isso de volta em uma string "321"e deixa no pipeline. A próxima (última) iteração do loop reverte a entrada para "54". Então agora nosso pipeline é "321", "54". Isso é encapsulado em parênteses, ()para que seja reformado em uma matriz e -joineditado novamente com zeros para produzir a sequência de saída resultante"321054". Isso é deixado no pipeline e a saída para o console está implícita.

Se houver zeros subsequentes na entrada original, a matriz será preenchida com elementos nulos, portanto, há o número correto de zeros na saída. Por exemplo, 1230045-split0se transforma (123,,45)e as coisas continuam como acima.

Geléia, 5 bytes

ṣ0Uj0

Experimente online!

Fator, 35 bytes

Vencendo Pyfon e Clojure, booyah!

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

Essa função anônima é uma tradução literal dessa resposta em Python .

É bem simples, basta dividir a string em zeros, inverter todos os elementos da matriz resultante e juntar todos os elementos (incluindo as de comprimento zero) "0".

Aqui está um exemplo dele em execução em todos os casos de teste:

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 bytes

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

Recursivamente acumula o pedaço invertido até agora r, acrescentando-o quando a 0é atingido. Quando a sequência restante está vazia, ela também é descarregada r.

Os dois primeiros repetem algum código, mas não encontrei uma maneira mais curta de combiná-los (45 e 47 bytes):

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 bytes

\0cm_\0J

Explicação:

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

Experimente aqui!

JavaScript (ES6), 50 49 bytes

Versão da string:

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

Guardou um byte graças a @Kevin Lau!

Versão da matriz (60 bytes):

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

J, 20 18 bytes

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

Agradecemos a Zgarb por ajudar com isso! Pega uma lista separada por espaço como argumento correto.

-2 bytes graças ao Zgarb!

Clojure / ClojureScript, 44 caracteres

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

Mesma solução que outras, apenas mais detalhada graças a nomes de funções longos. Não publicaria por causa disso, mas supera outras respostas, por que não?

Funciona em qualquer tipo de sequência. No ClojureScript, isso também funciona em cadeias de caracteres, uma vez que elas são processáveis ​​como listas de caracteres, que são na verdade apenas cadeias de um comprimento, que são coerentes com números para coisas como pos?.

Haskell, 46 bytes

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

Exemplo de uso: (reverse=<<).split(oneOf"0") $ "0123004500678090"-> "0321005400876090".

Infelizmente, a splitfunção requer a importação cara. Divida a lista de entrada a cada 0, por exemplo split(oneOf"0") "0120030"- -> ["","0","12","0","","0","3","0",""], inverta cada bloco e concatene em uma única sequência.

F #, 103 bytes

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

Java, 179 bytes (com importação)

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

Recebe uma entrada de string e divide os caracteres por zero e os adiciona novamente chamando o método add na classe StringJoiner.

Oracle SQL 11.2, 131 123 bytes

Abusando de funções XML.

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

Perl, 22 bytes

Incluindo +1 para a -popção:

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

Esta é uma substituição bastante trivial - desculpe ser tão chata. Observe que, se sua entrada for finalizada com nova linha (por exemplo, usando perl -pe 's/[^0]+/reverse$&/eg' <<<21000543no Bash), ela trará a nova linha com os dígitos - use echo -nou printfpara evitar isso. Como alternativa, por um custo de um byte adicional, altere a classe de caracteres para [1-9]e você poderá fornecer muitas entradas, uma por linha.

C, 105 bytes

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

Ligue fcom a lista de dígitos como uma sequência terminada em nulo e ela imprimirá a saída correta.

Ungolfed e explicou:

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

Veja ao vivo em Coliru

Perl 5, 52 bytes

Uma sub-rotina:

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

Na verdade, 22 bytes

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

Isso realmente me fez notar que há um erro no comando split - ele não preserva as divisões vazias. Como solução alternativa, envolvo a sequência de entrada com as antes de dividir, inverter e unir e, em seguida, removo os as no final. A entrada é tomada como uma sequência, a saída é uma lista de cadeias de caracteres únicos.

Experimente online

Explicação:

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

solução falho!

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

ungolfed:

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 bytes

Golfe

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

Ungolfed

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

Código completo

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 bytes

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

Usa em #{0}vez de pos?(salve 1 byte concatenando com %) e usando em mapcatvez de (flatten(map. Ainda mais que o fator .