Umgekehrte positive Läufe


22

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 .

Antworten:



8

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.


7

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.



5

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!


4

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!


4

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.


Ich würde sagen, es sieht eher aus wie Text in einer lustigen Form, wenn ich ihn anschaue. Vielleicht sollte ich dieses Teleskop wegstellen.
Katze

1
@cat Nein, nein, behalte es bei, aber sieh dir das Lambda an, wenn du es tust.
Conor O'Brien


3

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.


1
Willkommen bei PPCG :) Sie sollten in der Lage sein, "0".joinden Zusatz und die Scheibe zu tun und dann fallen zu lassen.
FryAmTheEggman

@FryAmTheEggman danke für den Tipp
1232

Kein Problem :) Sie können auch das Leerzeichen zwischen ]und entfernen for. Auf unserer Seite mit Tipps finden Sie weitere Hinweise.
FryAmTheEggman

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

3

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}


2

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.



2

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"


2

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

Ich denke, Sie brauchen noch ein Paar Klammern in Zeile 2:r%(h:t)=(h:r)%t
nimi


1

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)

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!


1

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


1

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.


1

F #, 103 Bytes

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

1

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.


1

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

1

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.


1

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


0

Perl 5, 52 Bytes

Ein Unterprogramm:

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

-afunktioniert nicht (zumindest in Strawberry), wenn die Eingabezeichenfolge auf endet 0, da split/\b/das $/mit dem einschließt 0.
msh210

0

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)

0

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

1
Ich glaube, diese Methode hat einen Fehler, wenn eine umzukehrende Zeichenfolge eine Teilmenge einer anderen ist. Wenn die Eingabe gegeben würde 01201230, würde dies zurückkehren 02102130. Dies liegt daran, dass die String.Replace-Methode alle Vorkommen der ersten Zeichenfolge durch die zweite ersetzt. Dieser Fehler würde auch verursacht, wenn ein Muster bei der Umkehrung auftaucht (zurückkehren 0120210würde 0120120).
Xynariz

Ich habe nicht einmal daran gedacht ..
downrep_nation

0

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

Ich habe gerade bemerkt, dass @downrep_nation hier bereits eine Lösung für C # gepostet hat, die meinen Code um 2 Bytes
übertrifft

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

Wenn Sie die sVariable vorne mit rund deklarieren t[], können Sie die Typdeklaration von sin der for-Schleife weglassen ?
Cyoce

Nein, ich habe es überprüft, erweitert für Schleifen benötigen Sie eine neu deklarierte Variable.
Hoffentlich hilfreich

huh. Das ist komisch. Na
ja

0

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 .

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.