Carreras positivas inversas

22

Entrada

Su entrada es una lista de números de un solo dígito en cualquier formato razonable, incluida una cadena de dígitos. La entrada no estará vacía.

Salida

Su salida será la lista de entrada, pero con cada ejecución máxima de dígitos distintos de cero que se invierte.

Ejemplo

Considere la entrada

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

donde las ejecuciones distintas de cero se han marcado con flechas. Al invertir cada una de estas ejecuciones, obtenemos la salida

38859003841470

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Este desafío está relacionado, pero es mucho más complejo, ya que incluye procesamiento adicional de cadenas.

Casos de prueba

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación y una lista de ganadores por idioma. Para asegurarse de que su respuesta aparezca, comience con un encabezado del formulario

## Language, N bytes

Puede mantener los puntajes antiguos en el encabezado utilizando las etiquetas tachadas: <s>57</s>aparecerá como 57 .

Mostrar fragmento de código

code-golf array-manipulation Zgarb
fuente

Respuestas:

11

Pyth, 8

j0_Mcz\0

Dividir en ceros, invertir y volver a unir en ceros.

Banco de pruebas

FryAmTheEggman
fuente
8

IPOS , 5 bytes

'0!r%

%divide la cadena de entrada en ceros, aplica el comando r(inverso) a cada subcadena y une el resultado nuevamente en ceros.

Denker
fuente
7

Retina , 15 bytes

S`0
O%^$`.

¶
0

Pruébalo en línea! (Ligeramente modificado para ejecutar todos los casos de prueba a la vez).

Explicación

S`0

Divida la entrada en 0s, es decir, coloque cada ejecución (posiblemente vacía) de dígitos distintos de cero en su propia línea.

O%^$`.

Esto invierte cada línea, por:

  • Aplicando el escenario a cada línea individualmente con %.
  • Relacionando cada personaje individualmente con ..
  • Ordenando por el resultado de la sustitución ( $) con la cadena vacía (la segunda línea vacía). Es decir, no se ordena en absoluto, ya que todos los valores de clasificación son idénticos.
  • Luego invierte el orden de los caracteres ordenados.

Finalmente:

¶
0

Convierta los avances de línea en 0s.

Martin Ender
fuente
5

05AB1E , 6 bytes

Código:

0¡€R0ý

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Adnan
fuente
5

Julia, 30 bytes

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

Esta es una función anónima que acepta una cadena y devuelve una cadena. Para llamarlo, asígnelo a una variable.

La replacefunción proporciona la capacidad de reemplazar coincidencias de una expresión regular con el resultado de una función aplicada a cada coincidencia. En este caso, podemos usar nonzeros [^0]+y reemplazar esas ejecuciones con el resultado de la reversefunción aplicada al texto coincidente.

¡Verifique todos los casos de prueba en línea!

Alex A.
fuente
4

Retina, 25 24

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

Pruébalo en línea

¡Guardado 1 byte gracias a Martin!

Ordene los dígitos distintos de cero por el número de ceros que siguen al dígito, en orden inverso.

¡Vea la solución de Martin para un uso inteligente del modo por línea para obtener un programa más corto!

FryAmTheEggman
fuente
4

Jolf, 8 bytes

RΜGi0λ_0

Pruébalo aquí!

Explicación

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

La explicación del código se parece a una lambda si entrecierra los ojos.

Una respuesta equivalente de 8 bytes:

RΜGi0΅O0

Lo mismo, pero utiliza ΅O(string espejo lambda) en su lugar.

Conor O'Brien
fuente
Yo diría que se parece más a un texto en una forma divertida cuando lo entrecierro. Tal vez debería guardar este telescopio.
gato
1
@cat No, no, quédatelo, pero mira la lambda cuando lo hagas.
Conor O'Brien
3

Ruby, 29 bytes

->x{x.gsub /[^0]*/,&:reverse}
Perilla de la puerta
fuente
3

Python, 58 50 bytes

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

Toma una cadena x y se divide en ceros e invierte cada elemento en la división y agrega un cero y devuelve este menos el último cero.

1232
fuente
1
Bienvenido a PPCG :) Deberías poder hacer "0".joiny luego soltar la adición y el corte.
FryAmTheEggman
@FryAmTheEggman gracias por el consejo
1232
No hay problema :) También puede eliminar el espacio entre ]y for. Puede consultar nuestra página de consejos para obtener más sugerencias, si lo desea.
FryAmTheEggman
77
lambda x:"0".join(n[::-1]for n in x.split("0"))
orlp
3

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}

Feersum
fuente
2

PowerShell v2 +, 45 bytes

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

Abusando del casting implícito como si no hubiera un mañana. Probablemente no puede acortarse mucho más, ya que no hay un reverso incorporado que sea más corto que este truco de indexación.

Explicación

Un ejemplo de cómo funciona esto; supongamos que 123045fue la entrada $args. Después del -splitencendido 0, la tubería contendría una matriz (123,45). El primer bucle con |%{...}tiene el elemento actual $_igual a 123, que luego se convierte implícitamente en una cadena, luego se invierte con la []indexación. Eso lo convierte en ('3','2','1')un conjunto de caracteres. El bucle -joinlo vuelve a poner en una cadena "321"y lo deja en la tubería. La siguiente (última) iteración de bucle invierte la entrada "54". Así que ahora nuestra cartera es "321", "54". Eso está encapsulado en parens, ()por lo que se reformó en una matriz, y re . Eso queda en la tubería y la salida a la consola está implícita.-join a juntar con ceros para producir la cadena de salida resultante"321054"

Si hay ceros posteriores en la entrada original, la matriz se rellenará con elementos nulos, por lo que hay la cantidad correcta de ceros en la salida. Por ejemplo, se 1230045-split0convierte en (123,,45)y las cosas continúan como anteriormente.

AdmBorkBork
fuente
2

Factor, 35 bytes

¡Derrotando a Pyfon y Clojure, booyah!

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

Esta función anónima es una traducción literal de esta respuesta de Python .

Es bastante simple, solo divide la cadena en ceros, invierte cada elemento de la matriz resultante y une todos los elementos (incluidas las cadenas de longitud cero) con "0" .

Aquí hay un ejemplo de cómo se ejecuta en todos los casos de prueba:

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"

gato
fuente
2

Haskell, 45 bytes

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

Acumula recursivamente el trozo invertido hasta ahora r, precediéndolo cuando un0 se alcanza a. Cuando la cadena restante está vacía, también se descarga r.

Los dos primeros repiten algo de código, pero no encontré una forma más corta de combinarlos (45 y 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
([]%)
xnor
fuente
Creo que se necesita un mayor par de paréntesis en la línea # 2:r%(h:t)=(h:r)%t
Nombre del modelo
1

Pyke, 8 bytes

\0cm_\0J

Explicación:

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

Pruébalo aquí!

Azul
fuente
1

JavaScript (ES6), 50 49 bytes

Versión de cadena:

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

¡Ahorré un byte gracias a @Kevin Lau!

Versión de matriz (60 bytes):

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

J, 20 18 bytes

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

¡Gracias a Zgarb por ayudar con esto! Toma una lista separada por espacios como argumento correcto.

-2 bytes gracias a Zgarb!

Conor O'Brien
fuente
1

Clojure / ClojureScript, 44 caracteres

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

La misma solución que otras, solo que más detallada gracias a los nombres largos de funciones. No iba a publicarlo por eso, pero supera algunas otras respuestas, ¿por qué no?

Funciona en cualquier tipo de secuencia. En ClojureScript, esto también funciona en cadenas ya que las cadenas son procesables como listas de caracteres, que en realidad son solo cadenas de 1 longitud, que obligan a los números para cosas como pos?.

MattPutnam
fuente
1

Haskell, 46 bytes

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

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

Lamentablemente, la splitfunción requiere la costosa importación. Divida la lista de entrada en cada 0, por ejemplo, split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], invierta cada fragmento y concatene en una sola cadena.

nimi
fuente
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"
David Conrad
fuente
1

Java, 179 bytes (con importación)

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

Toma una entrada de cadena y divide los caracteres por cero y luego los vuelve a agregar llamando al método add en la clase StringJoiner.

1232
fuente
1

Oracle SQL 11.2, 131 123 bytes

Abusar de funciones XML.

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

Perl, 22 bytes

Incluyendo +1 para la -popción:

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

Esta es una sustitución bastante trivial, lamento ser tan aburrida. Tenga en cuenta que si su entrada está terminada en nueva línea (por ejemplo, usando perl -pe 's/[^0]+/reverse$&/eg' <<<21000543Bash), capturará la nueva línea con los dígitos; use echo -no printfpara evitar eso. Alternativamente, por un costo de un byte adicional, cambie la clase de caracteres a [1-9], y puede proporcionar muchas entradas, una por línea.

Toby Speight
fuente
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);}

Llame fcon la lista de dígitos como una cadena terminada en nulo e imprimirá la salida correcta.

Ungolfed y explicó:

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

Véalo en vivo en Coliru

Quentin
fuente
0

Perl 5, 52 bytes

Una subrutina:

{$_=pop;y/0/ /;map$i.=reverse,split/\b/;$i=~y/ /0/r}
msh210
fuente
-ano funciona (al menos en Strawberry) cuando la cadena de entrada termina 0, ya que split/\b/incluye el $/con 0.
msh210
0

En realidad, 22 bytes

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

Esto realmente me hizo notar que hay un error en el comando de división: no conserva divisiones vacías. Como solución alternativa, rodeo la cadena de entrada con as antes de dividir, invertir y unir, luego elimino la as al final. La entrada se toma como una cadena, la salida es una lista de cadenas de un solo carácter.

Pruébalo en línea

Explicación:

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)
Mego
fuente
0

C #, 131 bytes ##

solución defectuosa!

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

sin 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;
    }
downrep_nation
fuente
1
Creo que este método tiene un error cuando una cadena a invertir es un subconjunto de otra. Si se le da la entrada 01201230, esto volvería 02102130. Esto se debe a que el método String.Replace reemplaza todas las apariciones de la primera cadena con la segunda. Este error también se causaría si aparece un patrón cuando se invierte ( 0120210volvería 0120120).
Xynariz
Ni siquiera pensé en eso ..
downrep_nation
0

C #, 133 bytes

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

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

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;
        }
    }
}
auhmaan
fuente
Sólo se dio cuenta ahora que @downrep_nation ya había publicado aquí una solución para C #, que late mi código de 2 bytes ... (Puede ser más ....)
auhmaan
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);}
Con suerte
fuente
Si declaras el s variable en el frente con ry t[], ¿puede omitir la declaración de tipo de sen el bucle for?
Cyoce
No, lo comprobé, los bucles mejorados necesitan una variable recientemente declarada.
HopefulHelpful
eh Eso es raro. Oh bueno
Cyoce
0

Clojure, 37 bytes

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

Utiliza en #{0}lugar de pos?(ahorra 1 byte concatenando con% ) y usa en mapcatlugar de (flatten(map. Todavía más largo que Factor .

NikoNyrh
fuente