Corse positive inverse


22

Ingresso

Il tuo input è un elenco di numeri a una cifra in qualsiasi formato ragionevole, inclusa una stringa di cifre. L'input non sarà vuoto.

Produzione

L'output deve essere l'elenco di input, ma con ogni serie massima di cifre diverse da zero viene invertita.

Esempio

Considera l'input

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

dove le piste diverse da zero sono state contrassegnate da frecce. Invertire ciascuna di queste corse, otteniamo l'output

38859003841470

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Questa sfida è correlata, ma molto più complessa, poiché include un'ulteriore elaborazione delle stringhe.

Casi test

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

Classifica

Ecco uno snippet di stack per generare una classifica e un elenco di vincitori per lingua. Per assicurarti che la tua risposta venga visualizzata, avviala con un'intestazione del modulo

## Language, N bytes

Puoi mantenere i vecchi punteggi nell'intestazione usando i tag barrati: <s>57</s>appariranno come 57 .

Risposte:



8

IPOS , 5 byte

'0!r%

%divide la stringa di input su zero, applica il comando r(inverso) a ogni sottostringa e unisce il risultato su zero.


7

Retina , 15 byte

S`0
O%^$`.

¶
0

Provalo online! (Leggermente modificato per eseguire tutti i casi di test contemporaneamente.)

Spiegazione

S`0

Dividi l'input attorno a 0s, cioè posiziona ogni sequenza (possibilmente vuota) di cifre diverse da zero sulla propria riga.

O%^$`.

Ciò inverte ogni riga, mediante:

  • Applicando il palcoscenico su ciascuna linea individualmente con %.
  • Abbinando ogni personaggio individualmente con ..
  • Ordinandolo per il risultato della sostituzione ( $) con la stringa vuota (la seconda riga vuota). Cioè non si ordina affatto, poiché tutti i valori di ordinamento sono identici.
  • Quindi inverte l'ordine dei caratteri ordinati.

Finalmente:

¶
0

Trasforma i linefeed in 0s.


5

05AB1E , 6 byte

Codice:

0¡€R0ý

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .


5

Julia, 30 byte

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

Questa è una funzione anonima che accetta una stringa e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

La replacefunzione offre la possibilità di sostituire le corrispondenze di un'espressione regolare con il risultato di una funzione applicata a ciascuna corrispondenza. In questo caso possiamo ottenere nonzeros usando [^0]+e sostituire quelle esecuzioni con il risultato della reversefunzione applicata al testo corrispondente.

Verifica tutti i casi di test online!


4

Retina, 25 24

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

Provalo online

Salvato 1 byte grazie a Martin!

Ordina le cifre diverse da zero in base al numero di zeri che seguono la cifra, in ordine inverso.

Scopri la soluzione di Martin per un uso intelligente della modalità per linea per ottenere un programma più breve!


4

Jolf, 8 byte

RΜGi0λ_0

Provalo qui!

Spiegazione

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

La spiegazione del codice sembra una specie di lambda se strizzi gli occhi.

Una risposta equivalente a 8 byte:

RΜGi0΅O0

Stessa cosa, ma usa invece ΅O(string mirror lambda).


Direi che assomiglia di più a un testo in una forma divertente quando lo osservo. Forse dovrei mettere via questo telescopio.
gatto,

1
@cat No, no, tienilo, ma guarda la lambda quando lo fai.
Conor O'Brien,


3

Pitone, 58 50 byte

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

Prende una stringa x e si divide sugli zeri e inverte ogni elemento nella divisione e aggiunge uno zero e restituisce questo meno l'ultimo ultimo zero.


1
Benvenuto in PPCG :) Dovresti essere in grado di fare "0".joine quindi rilasciare l'aggiunta e la sezione.
FryAmTheEggman,

@FryAmTheEggman grazie per la punta
1232

Nessun problema :) Puoi anche rimuovere lo spazio tra ]e for. Puoi consultare la nostra pagina dei suggerimenti per ulteriori suggerimenti, se lo desideri.
FryAmTheEggman,

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

3

Mathematica, 30 byte

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

ad es. 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

Abusare del cast implicito come se non ci fosse un domani. Probabilmente non può essere molto più breve, in quanto non esiste un built-in per il contrario più breve di questo trucco di indicizzazione.

Spiegazione

Un esempio di come funziona - supponiamo che sia 123045stato l'input $args. Dopo l' -splitattivazione 0, la pipeline conterrà un array (123,45). Il primo ciclo con |%{...}ha l'elemento corrente $_uguale a 123, che viene quindi implicitamente lanciato come una stringa, quindi invertito con l' []indicizzazione. Questo lo rende ('3','2','1')un char-array. Il loop lo -joinrimette in una stringa "321"e lo lascia sulla pipeline. La successiva (ultima) ripetizione del ciclo inverte l'ingresso in "54". Così ora la nostra pipeline è "321", "54". È incapsulato in parentesi ()quindi viene riformulato in un array e reinserito -joininsieme agli zeri per produrre la stringa di output risultante"321054". Rimane sulla pipeline e l'output sulla console è implicito.

Se ci sono zeri successivi nell'input originale, l'array verrebbe popolato con elementi null, quindi ci sarà il numero corretto di zeri sull'output. Ad esempio, 1230045-split0si trasforma in (123,,45)e le cose continuano come sopra.



2

Fattore, 35 byte

Battere Pyfon e Clojure, booyah!

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

Questa funzione anonima è una traduzione letterale di questa risposta Python .

È abbastanza semplice, basta dividere la stringa su zero, invertire ogni elemento dell'array risultante e unire tutti gli elementi (comprese le stringhe di lunghezza zero) con "0" .

Ecco un esempio in esecuzione su tutti i casi di test:

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 byte

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

Accumula ricorsivamente il pezzo invertito finora r, facendolo precedere quando 0viene raggiunto un. Quando la stringa rimanente è vuota, si scarica ancher .

I primi due ripetono del codice, ma non ho trovato un modo più breve per combinarli (45 e 47 byte):

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

Penso che tu abbia bisogno di un'altra coppia di parentesi nella riga # 2:r%(h:t)=(h:r)%t
nimi,

1

Pyke, 8 byte

\0cm_\0J

Spiegazione:

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

Provalo qui!


1

JavaScript (ES6), 50 49 byte

Versione stringa:

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

Salvataggio di un byte grazie a @Kevin Lau!

Versione array (60 byte):

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

1

J, 20 18 byte

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

Grazie a Zgarb per l'aiuto in questo! Accetta un elenco separato da spazi come argomento corretto.

-2 byte grazie a Zgarb!


1

Clojure / ClojureScript, 44 caratteri

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

Stessa soluzione di altre, solo più dettagliata grazie ai nomi lunghi delle funzioni. Non lo avrei pubblicato per questo, ma batte alcune altre risposte, quindi perché no?

Funziona su qualsiasi tipo di sequenza. In ClojureScript, questo funziona anche con le stringhe poiché le stringhe sono elaborabili come elenchi di caratteri, che sono in realtà solo stringhe di una lunghezza, che costringono a numeri per cose come pos?.


1

Haskell, 46 byte

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

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

Purtroppo la splitfunzione richiede un'importazione costosa. Dividi l'elenco di input su ogni 0, ad es. split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], inverti ogni blocco e concatena in una singola stringa.


1

F #, 103 byte

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

1

Java, 179 byte (con importazione)

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

Accetta un input di stringa e divide i caratteri per zero, quindi li aggiunge di nuovo chiamando il metodo add sulla classe StringJoiner.


1

Oracle SQL 11.2, 131 123 byte

Abuso di funzioni XML.

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

1

Perl, 22 byte

Di cui +1 per l' -popzione:

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

Questa è una sostituzione piuttosto banale - mi dispiace essere così noioso. Nota che se il tuo input è terminato da una nuova riga (es. Usando perl -pe 's/[^0]+/reverse$&/eg' <<<21000543in Bash), prenderà la nuova riga con le cifre - usa echo -no printfper evitarlo. In alternativa, per un costo di un byte aggiuntivo, modifica la classe di caratteri in [1-9]e puoi fornire molti input, uno per riga.


1

C, 105 byte

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

Chiama fcon l'elenco di cifre come una stringa con terminazione nulla e stamperà l'output corretto.

Ungolfed e spiegato:

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

Guardalo dal vivo su Coliru


0

Perl 5, 52 byte

Una subroutine:

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

-anon funziona (almeno in Strawberry) quando termina la stringa di input 0, poiché split/\b/include il $/simbolo 0.
msh210,

0

In realtà, 22 byte

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

Questo in realtà mi ha fatto notare che c'è un bug nel comando split - non conserva le divisioni vuote. Per ovviare al problema, circondo la stringa di input con as prima di eseguire la divisione, il contrario e l'unione, quindi rimuovoa s alla fine. L'input viene considerato come una stringa, l'output è un elenco di stringhe a carattere singolo.

Provalo online

Spiegazione:

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

soluzione imperfetta!

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
Credo che questo metodo abbia un bug quando una stringa da invertire è un sottoinsieme di un'altra. Se dato l'input 01201230, questo ritornerebbe 02102130. Questo perché il metodo String.Replace sostituisce tutte le occorrenze della prima stringa con la seconda. Questo errore sarebbe causato anche se un modello si presentasse quando invertito ( 0120210sarebbe tornato 0120120).
Xynariz,

Non ci avevo nemmeno pensato ...
downrep_nation

0

C #, 133 byte


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

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

Ho appena notato che @downrep_nation aveva già pubblicato qui una soluzione per C #, che batte il mio codice di 2 byte ... (Può essere più ....)
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);}

Se dichiari la svariabile in primo piano con re t[], puoi omettere la dichiarazione del tipo di snel ciclo for?
Cyoce,

No, l'ho verificato, migliorato per i loop che richiedono una variabile dichiarata di recente.
Speriamo utile

eh. Quello è strano. Oh bene
Cyoce

0

Clojure, 37 byte

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

Usa #{0}invece di pos?(salva 1 byte concatenando con %) e usando mapcatinvece di (flatten(map. Ancora più a lungo di Factor .

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.