La sfida degli zero principali

31

La sfida

Dati due numeri interi come input ( xe y), output xcome una stringa con il maggior numero di zeri iniziali necessari per essere ylunghi senza il segno.

Regole

  • Se xha più di ycifre, invia xcome stringa senza modifiche.

  • L'output come numero intero non è accettato, anche se non ci sono zero iniziali.

  • Quando xè negativo, mantenere così -com'è e operare sul valore assoluto.

  • Il negativo ydeve essere trattato come 0, il che significa che l'output xè così com'è (ma come stringa)

Esempi:

IN: (1,1)   OUT: "1"
IN: (1,2)   OUT: "01"
IN: (10,1)  OUT: "10"
IN: (-7,3)  OUT: "-007"
IN: (-1,1)  OUT: "-1"
IN: (10,-1) OUT: "10"
IN: (0,0)   OUT: "0"
IN: (0,1)   OUT: "0"
IN: (0,4)   OUT: "0000"

Vince il codice più corto in byte, si applicano scappatoie standard.

code-golf  string 
— Brian H.
fonte
— Brian H.
1
Posso prendere x come stringa?
— Liefde:
cosa (-1,1)dà?
— Adám,
@ Adám lo ha aggiunto agli esempi.
— Brian H.
1
Un +segno guida è accettabile per i numeri positivi?
— Tom Carpenter,

Risposte:

4

Japt , 13 8 byte

Prende il primo input ( x) come stringa.

®©ùTV}'-

Provalo

Risparmiato un enorme 5 byte grazie a ETHproductions.

Spiegazione

Immissione implicita di stringa U=xe numero intero V=y.

® }'-si divide Uin un array sul simbolo meno, lo mappa su di esso e lo ricongiunge a una stringa con un simbolo meno.

©è AND logico ( &&) quindi se l'elemento corrente è true (una stringa non vuota) allora pad left ( ù) con 0 ( T) alla lunghezza V.

— ispido
fonte
Ben fatto! Puoi risparmiare un po 'semplicemente mappando -: ethproductions.github.io/japt/…
— ETHproductions
@ETHproductions: ottima chiamata. Grazie. Sono passato tanto tempo da quando l'ho fatto, avevo completamente dimenticato che puoi dividere, mappare e ricongiungere una stringa tutto in un unico metodo!
— Shaggy,
Sì, suppongo che la funzionalità dovrebbe essere spostata su q, che sarebbe quindi quella q-_©ùTVdi salvare 1 byte :-)
— ETHproductions
@ETHproductions, se ho capito bene, stai suggerendo che se una funzione viene passata come secondo argomento di S.q()(darci S.q(s,f)), Ssarebbe suddivisa s, eseguita fe ricongiunta s? Mi piace! :)
— Shaggy,
Sì, ho parlato con Oliver e non si a fare che (se approvata una funzione, fare la funzionalità normale, eseguito attraverso la funzione, e annullare il primo cambiamento, N.s, S/A.y, N.ìfarlo già) con un gruppo di metodi? Ho avuto una conversazione con qualcuno, non riesco proprio a ricordare chi ora: s
— ETHproductions
6

05AB1E , 11 10 byte

Input dato come amount_of_digits, number

ÎIÄg-×ì'-†

Provalo online!

Spiegazione

Î            # push 0 and first input
 IÄ          # push the absolute value of the second input
   g         # length
    -        # subtract, (input1-len(abs(input2))
     ×       # repeat the zero that many times
      ì      # prepend to the second input
       '-†   # move any "-" to the front
— Emigna
fonte
Sembra che questa sia la risposta vincente finora, se domani non lo farò, lo accetterò.
— Brian H.
sei stato superato :(
— Brian H.
@BrianH. Effettivamente ho :)
— Emigna il
5

Java (OpenJDK 8) , 47 byte

x->y->"".format("%0"+((y<1?1:y)-(x>>31))+"d",x)

Provalo online!

All'inizio ho pensato, facile, massimo 30 caratteri (che è piuttosto breve quando si manipolano le stringhe in Java). Quindi sono avvenute le eccezioni.

— Olivier Grégoire
fonte
5

JavaScript (ES6), 42

Ricorsivo, parametri in ordine inverso, prima y poi x. E Currying

y=>r=x=>x<0?'-'+r(-x):`${x}`.padStart(y,0)

Test

var F=
y=>r=x=>x<0?'-'+r(-x):`${x}`.padStart(y,0)

;`IN: (1,1)   OUT: "1"
IN: (1,2)   OUT: "01"
IN: (10,1)  OUT: "10"
IN: (-7,3)  OUT: "-007"
IN: (-1,1)  OUT: "-1"
IN: (10,-1) OUT: "10"
IN: (0,0)   OUT: "0"
IN: (0,1)   OUT: "0"
IN: (0,4)   OUT: "0000"`
.split(`\n`).map(r => r.match(/[-\d]+/g))
.forEach(([x,y,k])=>{
  o = F(y)(x)
  ok = o == k
  console.log(ok?'OK':'KO',x,y,'->', o)
})
Espandi frammento

— edc65
fonte
Sebbene impressionante, ritengo che questa risposta salti leggermente le regole definendo la funzione f(y)(x)anziché f(x,y).
— Styletron,
Leggendo le regole del "curry", volevo aggiungere che la mia obiezione era più sui parametri invertiti e non sul curry stesso.
— Styletron,
1
@styletron l'ordine dei parametri non è specificato nella sfida. Quindi posso approfittare di questo
— edc65,
Dang, y=>r=x=>x<0?'-'+r(-x):(x+='')[y-1]?x:r(0+x)arriva così vicino ...
— ETHproductions
non ho problemi con le persone che invertono l'ordine di input.
— Brian H.
5

Buccia , 12 byte

Ö±Ωo≥⁰#±:'0s

Provalo online!

Spiegazione

Ö±Ωo≥⁰#±:'0s  Inputs are y=4 and x=-20
           s  Convert x to string: "-20"
        :'0   Prepend '0'
  Ω           until
      #±      the number of digits
   o≥⁰        is at least y: "00-20"
Ö±            Sort by is-digit: "-0020"
              Print implicitly.
— Zgarb
fonte
5

R, 56 48 byte

function(x,y)sprintf(paste0("%0",y+(x<0),"d"),x)

Provalo online!

-8 byte grazie a djhurio

Spiegazione

  • sprintf("%0zd",x)ritorna xcome una stringa riempita di zeri per essere di lunghezzaz
  • paste0("%0",y+(x<0),"d")costruisce la stringa "%0zd", dove si ztrova y, più 1 se xè inferiore a zero
  • Se zè inferiore al numero di cifre in x, xviene stampato come una stringa così com'è
— duckmayr
fonte
48 bytefunction(x,y)sprintf(paste0("%0",y+(x<0),"d"),x)
— djhurio il
@djhurio geniale! Penso che meriterebbe un'altra risposta piuttosto che una mia modifica, che ne dici?
— duckmayr,
Puoi farlo come una modifica. Questa soluzione non è molto diversa, solo usando una funzione diversa.
— djhurio,
4

Alice , 23 byte

/oRe./'+Ao
\I*tI&0-R$@/

Provalo online!

L'input deve essere separato da avanzamento riga con il numero sulla prima riga e la larghezza sulla seconda.

Spiegazione

/...
\...@/

Questo è il solito schema per i programmi lineari in modalità Ordinale. L'unico problema in questo caso è questo bit:

.../...
...&...

Questo fa sì che l'IP entri in modalità Cardinale in verticale ed esegua solo &in modalità Cardinale prima di riprendere in modalità Ordinale.

Spiegando il flusso di controllo a zigzag, si ottiene:

IRt.&'-A$o*eI/&/0+Ro@

I    Read the first line of input (the value) as a string.
R    Reverse the string.
t.   Split off the last character and duplicate it.
&    Fold the next command over this string. This doesn't really do anything,
     because the string contains only one character (so folding the next
     command is identical to executing it normally).
'-   Push "-".
A    Set intersection. Gives "-" for negative inputs and "" otherwise.
$o   If it's "-", print it, otherwise it must have been a digit which we
     leave on the stack.
*    Join the digit back onto the number. If the number was negative, this
     joins the (absolute value of the) number to an implicit empty string,
     doing nothing.
e    Push an empty string.
I    Read the width W.
/&/  Iterate the next command W times.
0    Append a zero. So we get a string of W zeros on top of the absolute
     value of the input number.
+    Superimpose. This takes the character-wise maximum of both strings
     and appends extraneous characters from the longer string. Since the
     string of zeros can never be larger than the digits in the input,
     the input itself will be uneffected, but extraneous zeros are appended,
     padding the string to the required length.
R    Reverse the result.
o    Print it.
@    Terminate the program.

Ecco due alternative, anche a 23 byte, che usano il cardinale H( abs ) per sbarazzarsi di -:

/R.I&0-RoH
\Ie#\'+Ao\@/


/R.H#/.+Xo
\Ie\I&0QRo@/

In linea di principio, si tratta di un comando più breve, ma &non si adatta a una posizione in cui è presente una stringa di 1 carattere nello stack, quindi dobbiamo saltarla con a #.

— Martin Ender
fonte
4

Carbone , 16 13 byte

‹Ｎ⁰﹪⁺⁺%0ηd↔Ｉθ

Provalo online!

Questo è il più breve che potrei ottenere usando Charcoal senza stampare spazi bianchi iniziali o finali. Almeno ora sto cominciando a capire come usare la Modulofunzione per formattare le stringhe.

Il codice deverbosed è il seguente:

Print(Less(InputNumber(),0));    # Prints a - if the first input is less than 0
Print(Modulo(Add(Add("%0",h),"d"),Abs(Cast(q))));   # q: first input;  h: second input
  • 3 byte salvati grazie a Neil!
— Charlie
fonte
1
Stampare -o niente è davvero facile in Carbone: stampare 1 stampa -mentre stampare 0 non stampa nulla. Quindi, il ternario è superfluo, risparmiando 3 byte.
— Neil,
Se si scambia il InputNumber()con il Cast(q), penso che si possa quindi passare a un confronto di stringhe per salvare un altro byte.
— Neil,
@Neil sapevo che avrei potuto semplificare il Ternary!
— Charlie,
4

PHP, 45 byte

printf("%0".($argv[2]+(0>$n=$argv[1])).d,$n);

o

[,$n,$e]=$argv;printf("%0".($e+(0>$n)).d,$n);       # requires PHP 7.1 or later

Corri con -nro provali online .

— Titus
fonte
Ricezione di un errore durante l'esecuzione del codice in quel collegamento.
— Shaggy,
@Shaggy La seconda versione richiede PHP 7.1
— Titus
Ho continuato a parlare di questo e sono arrivato esattamente a questa risposta. Credo che questa sia la versione ottimale
— Ismael Miguel,
3

Mathematica, 118 byte

(j=ToString;If[#2<=0,j@#,If[(z=IntegerLength@#)>=#2,t=z,t=#2];s=j/@PadLeft[IntegerDigits@#,t];If[#>=0,""<>s,"-"<>s]])&


Provalo online!

— J42161217
fonte
3

Mathematica, 63 62 byte

If[#<0,"-",""]<>IntegerString[#,10,Max[#2,IntegerLength@#,1]]&

Provalo online!

— MatjazGo
fonte
2
Benvenuti in PPCG! Penso che questo non stia facendo esattamente quello che vuoi. Probabilmente intendevi IntegerLengthinvece di IntegerDigits. È possibile salvare un byte utilizzando IntegerLength@#invece di IntegerLength[#]però.
— Martin Ender,
Grazie! Stavo copiando il codice da un altro computer a mano dove lo stavo testando e in effetti ho sbagliato a digitare IntegerDigits for IntegerLength. Dovrebbe funzionare ora. Ho anche aggiunto un link TIO con tutti i casi di test nella descrizione della sfida (+1) che mostra che funziona come previsto. Grazie anche per il suggerimento per il salvataggio di un byte extra! Non so come l'ho perso prima. :)
— MatjazVo
2

Excel, 29 byte

Utilizzo della TEXTfunzionalità di Excel ("Converte un valore in testo in un formato numerico specifico").

xin A1, yin B1

=TEXT(A1,REPT("0",MAX(1,B1)))
— Wernisch
fonte
Puoi eliminare i )))-3 byte convertendoli in Fogli Google
— Taylor Scott il
2

Japt , 14 12 byte

Salvato 2 byte grazie a @ETHproductions

s r"%d+"_ù0V

Provalo online

— Oliver
fonte
È un po 'più economico mantenere il segno meno e pasticciare con le cifre:
— provalo
@ETHproductions: oppure prendi xcome stringa per 10 byte .
— Shaggy,
@ETHproductions grazie ragazzi. Lo aggiornerò quando torno alla mia scrivania.
— Oliver,
@Shaggy Sembra che tu abbia pubblicato la tua risposta, quindi userò il trucco di ETHproduction. Grazie comunque.
— Oliver,
Oliver, quel 10 byte è solo la soluzione a 12 byte di @ ETHproduction aggiornata a Japt 2.0a0 con Uuna stringa che ci consente di giocare a golf con i primi 2 caratteri.
— Shaggy,
2

PowerShell , 25 40 byte

param($a,$b)$a|% *g $("D$b"*($b|% *o 0))

Provalo online!

Spiegazione

Questo chiama .ToString()il numero con una stringa di formato generata, ma lo moltiplica per -1, 0 o 1 in base al fatto che $b( y) sia rispettivamente negativo, 0 o positivo; questo serve a gestire yvalori negativi che le stringhe di formato non fanno da sole.

Ciò sembra richiedere il confezionamento di numeri negativi in ​​un sottostatement ()affinché funzioni, il che è solo una stranezza dell'invocazione quando si usano i valori letterali; se passasse variabili di tipo intero, non sarebbe necessario.

— briantist
fonte
Sembra che entrambi falliscano quando yè negativo.
— Shaggy,
@Shaggy ugh buona cattura. Rimossa la seconda soluzione del tutto e risolto il primo, grazie!
— Briantist,
Ahi, 15 byte! Scusate!
— Shaggy,
@Shaggy heh, uno di questi giorni in realtà scriverò il linguaggio del golf basato su PowerShell a cui stavo pensando. Questo in realtà mi ha spinto a ricercare un po 'di più e ad avvicinarmi all'avvio, quindi grazie per quello;)
— briantist
2

C # 6.0, 35 byte

(x,y)=>(x.ToString($"D{y<0?0:y}"));

Soluzione alternativa (51 byte)

(x,y)=>(x.ToString(string.Format("D{0}",y<0?0:y)));
— user76514
fonte
1

C (gcc) , 45 byte

f(x,y){printf("%s%0*i","-"+(x>=0),y,abs(x));}

Provalo online!

Spiegazione

printf formatta tre argomenti:

%s      ->    "-"+(x>=0)
%0*i    ->    y
        ->    abs(x)

%sformatta la stringa "-"+(x>=0). "-"è davvero solo un indirizzo, qualcosa del genere 41961441. In memoria, sembra qualcosa del genere:

MEMORY ADDRESS | 41961441  41961442 ...
VALUE          | 45 ('-')  0 (0x00) ...

Quando formattato in una stringa, C prende l'indirizzo (diciamo 41961441) e continua ad acquisire caratteri fino a quando non viene raggiunto un byte nullo (0x00). Quando x è minore di zero, il valore "-"+(x>=0)ha quello dell'indirizzo originale (41961441). Altrimenti, x>=0è 1, quindi l'espressione diventa "-"+1, che indica il byte null dopo "-", che non stampa nulla.

%0*istampa un numero intero imbottito con un numero specificato di 0s. yindica questo numero. Appoggiamo abs(x)per evitare il negativo in alcuni argomenti.

— Conor O'Brien
fonte
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.