Eingang

Ihre Eingabe besteht aus einer Liste einstelliger Zahlen in einem angemessenen Format, einschließlich einer Ziffernfolge. Die Eingabe wird nicht leer sein.

Ausgabe

Ihre Ausgabe soll die Eingabeliste sein, wobei jedoch jede maximale Folge von Ziffern ungleich Null umgekehrt wird.

Beispiel

Betrachten Sie die Eingabe

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

wo die Nicht-Null-Läufe mit Pfeilen markiert wurden. Wenn wir jeden dieser Läufe umkehren, erhalten wir die Ausgabe

38859003841470

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Diese Herausforderung ist verwandt, aber viel komplexer, da sie zusätzliche Zeichenfolgenverarbeitung enthält.

Testfälle

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

Bestenliste

Hier ist ein Stack-Snippet, um eine Rangliste und eine Liste der Gewinner nach Sprache zu erstellen. Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie sie mit einer Kopfzeile des Formulars

## Language, N bytes

Sie können alte Ergebnisse in der Kopfzeile behalten, indem Sie die durchgestrichenen Tags verwenden: <s>57</s>wird als 57 angezeigt .

/* 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

Nach Nullen teilen, umkehren und nach Nullen wieder zusammenfügen.

Test Suite

IPOS , 5 Bytes

'0!r%

%teilt die Eingabezeichenfolge auf Nullen auf, wendet den Befehl r(rückwärts) auf jede Teilzeichenfolge an und setzt das Ergebnis auf Nullen zurück.

Netzhaut , 15 Bytes

S`0
O%^$`.

¶
0

Probieren Sie es online! (Leicht modifiziert, um alle Testfälle gleichzeitig auszuführen.)

Erläuterung

S`0

Teilen Sie die Eingabe um 0s auf, setzen Sie also jeden (möglicherweise leeren) Lauf von Ziffern ungleich Null in eine eigene Zeile.

O%^$`.

Dies kehrt jede Zeile um, indem:

• Anwenden der Bühne auf jede Linie einzeln mit %.
• Jedem Charakter einzeln mit . .
• Sortieren nach dem Ergebnis der Ersetzung ( $) durch die leere Zeichenfolge (die leere zweite Zeile). Dh es wird überhaupt nicht sortiert, da alle Sortierwerte identisch sind.
• Kehrt dann die Reihenfolge der sortierten Zeichen um.

Endlich:

¶
0

Drehen Sie die Zeilenvorschübe zurück in 0s.

05AB1E , 6 Bytes

Code:

0¡€R0ý

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Julia, 30 Bytes

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

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Die replaceFunktion bietet die Möglichkeit, Übereinstimmungen eines regulären Ausdrucks durch das Ergebnis einer Funktion zu ersetzen, die auf jede Übereinstimmung angewendet wird. In diesem Fall können wir Nonzeros verwenden [^0]+und diese Läufe durch das Ergebnis der reverseFunktion ersetzen, die auf den übereinstimmenden Text angewendet wird.

Überprüfen Sie alle Testfälle online!

Retina, 25 24

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

Probieren Sie es online aus

1 Byte gespart dank Martin!

Sortieren Sie die Ziffern ungleich Null in umgekehrter Reihenfolge nach der Anzahl der auf die Ziffer folgenden Nullen.

Sehen Sie sich Martins Lösung für eine clevere Verwendung des Zeilenmodus an, um ein kürzeres Programm zu erhalten!

Jolf, 8 Bytes

RΜGi0λ_0

Probieren Sie es hier aus!

Erläuterung

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

Die Code-Erklärung sieht aus wie ein Lambda, wenn Sie blinzeln.

Eine äquivalente 8-Byte-Antwort:

RΜGi0΅O0

Das Gleiche, aber es wird ΅Ostattdessen (String Mirror Lambda) verwendet.

Ruby, 29 Bytes

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

Python, 58 50 Bytes

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

Nimmt einen String x auf, teilt die Nullen auf und kehrt jedes Element in der Teilung um, fügt eine Null hinzu und gibt das Minus der letzten Null zurück.

Mathematica, 30 Bytes

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

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

PowerShell v2 +, 45 Byte

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

Missbrauch des impliziten Castings, als gäbe es kein Morgen. Kann wahrscheinlich nicht viel kürzer werden, da es kein integriertes Reverse gibt, das kürzer ist als dieser Indizierungstrick.

Erläuterung

Ein Beispiel dafür, wie das funktioniert - nehmen wir an, 123045die Eingabe $args. Nach dem -splitauf 0würde die Pipeline ein Array enthalten (123,45). Die erste Schleife mit |%{...}hat das aktuelle Element $_gleich 123, das dann implizit als Zeichenfolge umgewandelt und mit der []Indizierung umgekehrt wird . Das macht es ('3','2','1')zu einem char-Array. Die Schleife -joinfügt das wieder in einen String ein "321"und belässt es in der Pipeline. Die nächste (letzte) Schleifeniteration kehrt die Eingabe in um "54". So , jetzt unsere Pipeline ist "321", "54". Das ist in Parens eingekapselt, ()so dass es in ein Array umgewandelt wird, und wieder . Dies verbleibt in der Pipeline und die Ausgabe an die Konsole ist implizit.-join zusammen mit Nullen zurückgeschnitten wird, um die resultierende Ausgabezeichenfolge zu erzeugen"321054"

Wenn die ursprüngliche Eingabe nachfolgende Nullen enthält, wird das Array mit Nullelementen gefüllt, sodass die Ausgabe die richtige Anzahl von Nullen enthält. Zum Beispiel wird 1230045-split0zu (123,,45)und es geht weiter wie oben.

Gelee, 5 Bytes

ṣ0Uj0

Probieren Sie es online!

Faktor 35 Byte

Pyfon und Clojure besiegen, Booyah!

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

Diese anonyme Funktion ist eine wörtliche Übersetzung dieser Python-Antwort .

Es ist ganz einfach: Teilen Sie die Zeichenfolge in Nullen auf, kehren Sie jedes Element des resultierenden Arrays um und verbinden Sie alle Elemente (einschließlich Zeichenfolgen mit der Länge Null) mit "0".

Hier ist ein Beispiel dafür, wie es in allen Testfällen ausgeführt wird:

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

rSammelt rekursiv den bis dahin umgedrehten Chunk vor dem 0Erreichen von a. Wenn die verbleibende Zeichenfolge leer ist, wird sie ebenfalls entladen r.

Die ersten beiden wiederholen Code, aber ich habe keinen kürzeren Weg gefunden, um sie zu kombinieren (45 und 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

Erläuterung:

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

Probieren Sie es hier aus!

JavaScript (ES6), 50 49 Bytes

String-Version:

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

Dank @Kevin Lau ein Byte gespart!

Array-Version (60 Byte):

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

J, 20 bis 18 Bytes

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

Vielen Dank an Zgarb für die Hilfe! Nimmt eine durch Leerzeichen getrennte Liste als richtiges Argument.

-2 Bytes dank Zgarb!

Clojure / ClojureScript, 44 Zeichen

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

Gleiche Lösung wie andere, nur ausführlicher dank langer Funktionsnamen. Wollte es deswegen nicht posten, aber es schlägt ein paar andere Antworten, also warum nicht?

Funktioniert mit jedem Sequenztyp. In ClojureScript funktioniert dies auch für Zeichenfolgen, da Zeichenfolgen als Listen von Zeichen verarbeitet werden können, bei denen es sich eigentlich nur um Zeichenfolgen mit einer Länge handelt, die für Dinge wie z pos?.

Haskell, 46 Bytes

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

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

Leider spliterfordert die Funktion den teuren Import. Teilen Sie die Eingabeliste bei jedem auf 0, z. B. split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], kehren Sie jeden Block um und verketten Sie ihn zu einer einzelnen Zeichenfolge.

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 (mit Import)

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

Nimmt eine Zeichenfolge-Eingabe auf, teilt die Zeichen durch Null und fügt sie dann wieder hinzu, indem die add-Methode für die StringJoiner-Klasse aufgerufen wird.

Oracle SQL 11.2, 131 123 Bytes

Missbrauch von XML-Funktionen.

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

Perl, 22 Bytes

Einschließlich +1 für -pOption:

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

Dies ist ein ziemlich trivialer Ersatz - tut mir leid, dass ich so langweilig bin. Beachten Sie, dass Ihre Eingabe bei Zeilenumbrüchen (z. B. bei Verwendung von perl -pe 's/[^0]+/reverse$&/eg' <<<21000543in Bash) die Zeilenumbrüche mit den Ziffern erfasst - verwenden Sie echo -noder printf, um dies zu vermeiden. Ändern Sie alternativ für ein zusätzliches Byte die Zeichenklasse in [1-9], und Sie können mehrere Eingaben vornehmen, eine pro Zeile.

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

Anruf f mit der Liste der Ziffern als nullterminierte Zeichenfolge auf, und es wird die richtige Ausgabe gedruckt.

Ungolfed und erklärte:

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

Sehen Sie es live auf Coliru

Perl 5, 52 Bytes

Ein Unterprogramm:

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

Eigentlich 22 Bytes

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

Dadurch habe ich festgestellt, dass der Befehl split einen Fehler enthält - leere Teilungen werden nicht beibehalten. aUm dieses Problem zu umgehen, umgebe ich die Eingabezeichenfolge vor dem Teilen, Umkehren und Verbinden mit s und entferne dann das as am Ende. Die Eingabe wird als Zeichenfolge interpretiert, die Ausgabe ist eine Liste von Zeichenfolgen mit nur einem Zeichen.

Probieren Sie es online aus

Erläuterung:

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

Lösung fehlerhaft!

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

133 Bytes

Golf gespielt

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

Vollständiger Code

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

Verwendet #{0}anstelle von pos?(1 Byte durch Verketten mit %) und verwendet mapcatanstelle von (flatten(map. Immer noch länger als Factor .