вход

Ваш ввод представляет собой список однозначных чисел в любом приемлемом формате, включая строку цифр. Ввод не будет пустым.

Выход

Ваш вывод должен быть входным списком, но при каждом обращении максимального числа ненулевых цифр.

пример

Рассмотрим вход

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

где ненулевые пробеги были отмечены стрелками. Обращая каждый из этих прогонов, мы получаем вывод

38859003841470

Правила и оценки

Вы можете написать полную программу или функцию. Побеждает меньшее количество байтов, и стандартные лазейки запрещены.

Эта проблема связана, но гораздо сложнее, поскольку включает в себя дополнительную обработку строк.

Контрольные примеры

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

Leaderboard

Вот фрагмент стека для генерации списка лидеров и списка победителей по языкам. Чтобы убедиться, что ваш ответ появляется, начните с заголовка формы

## Language, N bytes

Вы можете сохранить старые результаты в заголовке с помощью зачеркнутых тегов: <s>57</s>будет отображаться как 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>

Пиф, 8

j0_Mcz\0

Разделить на нули, повернуть вспять и присоединиться к нулям.

Тестирование

IPOS , 5 байтов

'0!r%

%разбивает входную строку на нули, применяет команду r(reverse) к каждой подстроке и присоединяет результат обратно к нулям.

Сетчатка , 15 байт

S`0
O%^$`.

¶
0

Попробуйте онлайн! (Немного изменен для запуска всех тестовых случаев одновременно.)

объяснение

S`0

Разделите ввод вокруг 0s, то есть поместите каждый (возможно, пустой) набор ненулевых цифр в свою строку.

O%^$`.

Это переворачивает каждую строку:

• Применяя сцену к каждой строке индивидуально с %.
• Соответствие каждого персонажа индивидуально с ..
• Сортировка по результату подстановки ( $) с пустой строкой (пустой второй строкой). Т.е. он не сортируется вообще, поскольку все значения сортировки идентичны.
• Затем меняет порядок отсортированных символов.

В заключение:

¶
0

Превратите перевод строки обратно в 0s.

05AB1E , 6 байтов

Код:

0¡€R0ý

Объяснение:

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

Использует кодировку CP-1252 . Попробуйте онлайн! ,

Юлия, 30 байт

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

Это анонимная функция, которая принимает строку и возвращает строку. Чтобы вызвать его, присвойте его переменной.

replaceФункция обеспечивает возможность замены матчей регулярного выражения с результатом функции применительно к каждой игре. В этом случае мы можем получить ненулевые значения, используя [^0]+и заменить эти прогоны результатом reverseфункции, примененной к сопоставленному тексту.

Проверьте все контрольные примеры онлайн!

Сетчатка, 25 24

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

Попробуйте онлайн

Сохранено 1 байт благодаря Мартину!

Сортируйте ненулевые цифры по количеству нулей, следующих за цифрой, в обратном порядке.

См . Решение Мартина для умного использования режима для каждой строки, чтобы получить более короткую программу!

Джольф, 8 байт

RΜGi0λ_0

Попробуй это здесь!

объяснение

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

Объяснение кода выглядит как лямбда, если вы щурились.

Эквивалентный 8-байтовый ответ:

RΜGi0΅O0

То же самое, но ΅Oвместо этого используется (строковое зеркало лямбда).

Рубин, 29 байт

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

Python, 58 50 байт

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

Берет строку x и разделяет на нули и инвертирует каждый элемент в разбиении, добавляет ноль и возвращает этот минус последний ноль.

Mathematica, 30 байт

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

например Join@@Reverse/@#~SplitBy~Sign&[{1,2,3,0,0,5,9,0}]={3, 2, 1, 0, 0, 9, 5, 0}

PowerShell v2 +, 45 байт

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

Злоупотребление неявным кастингом, как будто завтра нет. Вероятно, не может быть намного короче, так как нет встроенной функции реверса, которая короче этого трюка с индексированием.

объяснение

Пример того, как это работает - предположим, 123045был вход $args. После -splitвключения 0конвейер будет содержать массив (123,45). Первый цикл с |%{...}имеет текущий элемент, $_равный 123, который затем неявно приводится в виде строки, а затем переворачивается при []индексации. Это делает его ('3','2','1')как массив символов. Цикл -joinпомещает это обратно в строку "321"и оставляет на конвейере. Следующая (последняя) итерация цикла меняет вход на "54". Так что теперь наш трубопровод "321", "54". Он инкапсулирован в паренах, ()поэтому преобразован в массив и преобразован -joinвместе с нулями для получения результирующей выходной строки."321054", Это остается на конвейере и вывод на консоль неявен.

Если в исходном входе есть последующие нули, массив будет заполнен нулевыми элементами, поэтому на выходе будет правильное количество нулей. Например, 1230045-split0превращается в (123,,45)и все продолжается, как указано выше.

Желе, 5 байт

ṣ0Uj0

Попробуйте онлайн!

Фактор, 35 байт

Бить Пифон и Clojure, буя!

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

Эта анонимная функция является буквальным переводом этого ответа Python .

Это довольно просто: просто разбить строку на нули, инвертировать каждый элемент полученного массива и соединить все элементы (включая строки нулевой длины) "0".

Вот пример его выполнения во всех тестовых случаях:

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 байт

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

До сих пор рекурсивно накапливает реверсированный кусок r, добавляя его при достижении a 0. Когда оставшаяся строка пуста, она также разряжается r.

Первые два повторяют некоторый код, но я не нашел более короткого способа их объединения (45 и 47 байт):

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

Пайк, 8 байт

\0cm_\0J

Объяснение:

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

Попробуй это здесь!

JavaScript (ES6), 50 49 байт

Струнная версия:

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

Сохраненный байт благодаря @Kevin Lau!

Версия массива (60 байт):

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

J, 20 18 байт

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

Спасибо Згарбу за помощь в этом! Принимает разделенный пробелами список в качестве правильного аргумента.

-2 байта благодаря Zgarb!

Clojure / ClojureScript, 44 символа

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

То же решение, что и у других, только более подробное благодаря длинным именам функций. Не собирался публиковать это из-за этого, но это бьет некоторые другие ответы, так почему бы и нет?

Работает на любой тип последовательности. В ClojureScript это также работает со строками, поскольку строки могут обрабатываться в виде списков символов, которые на самом деле представляют собой строки длиной 1, которые приводят к числам для подобных вещей pos?.

Haskell, 46 байтов

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

Пример использования: (reverse=<<).split(oneOf"0") $ "0123004500678090"-> "0321005400876090".

К сожалению, эта splitфункция требует дорогостоящего импорта. Разделите входной список на каждый 0, например split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], инвертируйте каждый фрагмент и объединяйте в одну строку.

F #, 103 байта

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

Java, 179 байт (с импортом)

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

Принимает строковые данные и разделяет символы на ноль, а затем добавляет их обратно, вызывая метод add класса StringJoiner.

Oracle SQL 11.2, 131 123 байта

Злоупотребление функциями XML.

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

Perl, 22 байта

Включая +1 для -pварианта:

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

Это довольно банальная замена - извините, что так скучно. Обратите внимание, что если ваш ввод завершается символом новой строки (например, используется perl -pe 's/[^0]+/reverse$&/eg' <<<21000543в Bash), он поймает символ новой строки с цифрами - используйте echo -nили printfизбегайте этого. В качестве альтернативы, для стоимости одного дополнительного байта измените класс символов на [1-9], и вы можете предоставить много входных данных, по одному на строку.

C 105 байт

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

Вызов fсо списком цифр в виде строки с нулевым символом в конце, и он выведет правильный вывод.

Разгромил и объяснил:

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

Смотрите это в прямом эфире на Coliru

Perl 5, 52 байта

Подпрограмма:

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

На самом деле, 22 байта

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

Это фактически заставило меня заметить, что в команде split есть ошибка - она ​​не сохраняет пустые разбиения. В качестве обходного пути я окружаю входную строку символом as перед выполнением разбиения, реверса и соединения, а затем удаляю as в конце. Ввод принимается как строка, вывод - список односимвольных строк.

Попробуйте онлайн

Объяснение:

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 байт ##

Решение ошибочно!

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 байта

Golfed

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

Полный код

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

Ява, 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 байт

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

Используется #{0}вместо pos?(сохранить 1 байт путем объединения с %) и использовать mapcatвместо (flatten(map. Все еще дольше, чем фактор .