Le principal défi des zéros

31

Le défi

Étant donné deux entiers en entrée ( xet y), la sortie xsous la forme d'une chaîne avec autant de zéros de tête nécessaires pour qu'elle soit ylongue sans le signe.

Règles

  • Si xa plus de ychiffres, sortez xsous forme de chaîne sans modification.

  • La sortie sous forme d'entier n'est pas acceptée, même s'il n'y a pas de zéros non significatifs.

  • Lorsque xest négatif, conservez-le -tel quel et opérez sur la valeur absolue.

  • Négatif ydoit être traité comme 0, ce qui signifie que vous produisez xtel quel (mais sous forme de chaîne)

Exemples:

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"

Le code le plus court en octets gagne, les failles standard s'appliquent.

code-golf string Brian H.
la source
sandbox: codegolf.meta.stackexchange.com/a/14264/69737
Brian H.
1
Puis-je prendre x comme chaîne?
LiefdeWen
qu'est-ce que ça (-1,1)donne?
1er
@ Adám l'a ajouté aux exemples.
Brian H.
1
Un +signe de tête est-il acceptable pour les nombres positifs?
Tom Carpenter

Réponses:

4

Japt , 13 8 octets

Prend la première entrée ( x) sous forme de chaîne.

®©ùTV}'-

L'essayer

Enregistré un énorme 5 octets grâce à ETHproductions.

Explication

Saisie implicite de chaîne U=xet d'entier V=y.

® }'-se divise Uen un tableau sur le symbole moins, mappe dessus et le rejoint en une chaîne avec un symbole moins.

©est un ET logique ( &&), donc si l'élément actuel est véridique (une chaîne non vide), remplissez left ( ù) avec 0 ( T) à la longueur V.

Hirsute
la source
Joli! Vous pouvez économiser beaucoup en cartographiant simplement -: ethproductions.github.io/japt/…
ETHproductions
@ETHproductions: Excellent appel. Merci. Cela fait si longtemps que je ne l'ai pas fait, j'avais complètement oublié que vous pouvez diviser, mapper et rejoindre une chaîne tout en une seule méthode!
Shaggy
Oui, je suppose que cette fonctionnalité devrait être déplacé vers q, qui serait alors q-_©ùTVpour sauver 1 octet :-)
ETHproductions
@ETHproductions, si je comprends bien, vous suggérez que si une fonction est passée comme deuxième argument de S.q()(nous donner S.q(s,f)), elle Sserait alors divisée s, parcourue fet rejointe s? Je l'aime! :)
Shaggy
Oui, ai - je parlé à Oliver et non - vous de le faire (si elle est adoptée une fonction, faire la fonctionnalité normale, exécutez par la fonction, et annuler le premier changement, N.s, S/A.y, N.ìdéjà le faire) avec un tas de méthodes? J'ai eu une conversation avec quelqu'un, je ne me souviens plus qui maintenant: s
ETHproductions
6

05AB1E , 11 à 10 octets

Entrée donnée en tant que amount_of_digits, number

ÎIÄg-×ì'-†

Essayez-le en ligne!

Explication

Î            # 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
la source
On dirait que c'est la réponse gagnante jusqu'à présent, si elle n'est pas améliorée demain, je l'accepterai.
Brian H.
vous avez été battu :(
Brian H.
@BrianH. En effet j'ai :)
Emigna
6

Python, 29 octets

Prenez l'entrée comme f(x,y). Utilisation de l' %opérateur de Python .

lambda x,y:'%0*d'%(y+(x<0),x)

Essayez-le en ligne!

Colera Su
la source
5

C #, 56 octets

Essayez-le en ligne!

a=>b=>(a<0?"-":"")+((a<0?-a:a)+"").PadLeft(b<0?0:b,'0')
LiefdeWen
la source
5

Java (OpenJDK 8) , 47 octets

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

Essayez-le en ligne!

Au début, je pensais, facile, 30 caractères max (ce qui est assez court lors de la manipulation de chaînes en Java). Puis les exceptions se sont produites.

Olivier Grégoire
la source
5

JavaScript (ES6), 42

Récursif, paramètres dans l'ordre inverse, d'abord y puis x. Et curry

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

Tester

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)
})
Développer l'extrait

edc65
la source
Bien qu'impressionnante, je pense que cette réponse contourne légèrement les règles en définissant la fonction f(y)(x)au lieu de f(x,y).
styletron
En lisant sur les règles de "curry", je voulais ajouter que mon objection était plus avec les paramètres inversés et non avec le curry lui-même.
styletron
1
@styletron l'ordre des paramètres n'est pas spécifié dans le défi. Je peux donc en profiter
edc65
Dang, y=>r=x=>x<0?'-'+r(-x):(x+='')[y-1]?x:r(0+x)si proche ...
ETHproductions
je n'ai aucun problème avec les gens qui inversent l'ordre d'entrée.
Brian H.
5

Python 3.6 , 28 37 octets

lambda x,y:f'{x:0{(y,0)[y<0]+(x<0)}}'

Essayez-le en ligne! (Cas de test de la réponse de Colera Su)

Profiter de la nouvelle façon de formater les chaînes en python 3.6

+9 octets à gérer y<0

Lescurel
la source
On dirait que cela échoue quand yest négatif: tio.run/##K6gsycjPM/…
Shaggy
Effectivement. Je suis donc avec 37 octets.
Lescurel
5

bash, 27 , 25 octets

-2 octets grâce à Bruce Forte

printf %0$[$2+($1<0)]d $1

essayez-le en ligne

Nahuel Fouilleul
la source
1
Vous pouvez enregistrer deux octets en insérant la longueur de remplissage. Aussi une autre intéressante (28 octets): printf %\ 0$[1+$1]d $2|xargs.
ბიმო
peut-être que vous voulez dire printf %\ 0$[1+$2]d $1|xargs, je ne me souvenais pas de ce format pour les numéros signés aussi astuce xargs pour supprimer l'espace de tête
Nahuel Fouilleul
5

Coque , 12 octets

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

Essayez-le en ligne!

Explication

Ö±Ω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
la source
5

R, 56 48 octets

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

Essayez-le en ligne!

-8 octets grâce à djhurio

Explication

  • sprintf("%0zd",x)renvoie xcomme une chaîne remplie de zéros pour être de longueurz
  • paste0("%0",y+(x<0),"d")construit la chaîne "%0zd", où zest y, plus 1 si xest inférieur à zéro
  • Si zest inférieur au nombre de chiffres x, xest imprimé sous forme de chaîne tel quel
duckmayr
la source
48 octetsfunction(x,y)sprintf(paste0("%0",y+(x<0),"d"),x)
djhurio
@djhurio brilliant! Je pense que cela justifierait une autre réponse plutôt qu'une édition de la mienne, que dites-vous?
duckmayr
Vous pouvez le faire en tant que montage. Cette solution n'est pas tellement différente, elle utilise simplement des fonctions différentes.
djhurio
4

Alice , 23 octets

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

Essayez-le en ligne!

L'entrée doit être séparée par des sauts de ligne avec le numéro sur la première ligne et la largeur sur la seconde.

Explication

/...
\...@/

C'est le cadre habituel pour les programmes linéaires en mode Ordinal. Le seul hic dans ce cas est ce bit:

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

Cela amène l'IP à entrer verticalement en mode Cardinal et à exécuter uniquement le &mode Cardinal avant de reprendre en mode Ordinal.

Déplier le flux de contrôle en zigzag donne alors:

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.

Voici deux alternatives, également à 23 octets, qui utilisent Cardinal H( abs ) pour se débarrasser de -:

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


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

En principe, ce sont des commandes plus courtes, mais le &ne rentre pas dans une position où il y a une chaîne de 1 caractère sur la pile, nous devons donc la sauter avec un #.

Martin Ender
la source
4

Fusain , 16 13 octets

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

Essayez-le en ligne!

C'est le plus court que j'ai pu utiliser avec du charbon de bois sans imprimer d'espaces blancs de début ou de fin. Au moins, je commence maintenant à comprendre comment utiliser la Modulofonction pour formater les chaînes.

Le code déverbosé est le suivant:

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 octets économisés grâce à Neil!
Charlie
la source
1
Imprimer -ou rien n'est vraiment facile dans Charcoal: Imprimer 1 imprime -tout en imprimant 0 n'imprime rien. Ainsi, le ternaire est superflu, économisant 3 octets.
Neil
Si vous échangez le InputNumber()avec le Cast(q), je pense que vous pouvez ensuite passer à une comparaison de chaînes pour enregistrer un autre octet.
Neil
@Neil Je savais que je pouvais simplifier le Ternary!
Charlie
4

Rétine , 39 octets

\d+$
$*0
((\d)*),(?<-2>-0+|0)*(0*)
$3$1

Essayez-le en ligne!

L'entrée doit être séparée par des virgules avec le nombre en premier et la largeur en second.

Martin Ender
la source
4

PHP, 45 octets

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

ou

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

Courez avec -nrou essayez-les en ligne .

Titus
la source
Obtenir une erreur lors de l'exécution du code dans ce lien.
Shaggy
@Shaggy La deuxième version nécessite PHP 7.1
Titus
Je suis allé encore et encore à ce sujet, et je suis arrivé exactement à cette réponse. Je crois que c'est la version optimale
Ismael Miguel
3

Mathematica, 118 octets

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


Essayez-le en ligne!

J42161217
la source
3

Mathematica, 63 62 octets

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

Essayez-le en ligne!

MatjazGo
la source
2
Bienvenue chez PPCG! Je pense que cela ne fait pas tout à fait ce que vous voulez. Vous vouliez probablement dire IntegerLengthau lieu de IntegerDigits. Vous pouvez enregistrer un octet en utilisant IntegerLength@#au lieu de IntegerLength[#]bien.
Martin Ender
Merci! Je copiais le code d'un autre ordinateur à la main où je le testais et j'ai en effet mal tapé IntegerDigits pour IntegerLength. Ça devrait marcher maintenant. J'ai également ajouté un lien TIO avec tous les cas de test dans la description du défi (+1) montrant que cela fonctionne comme prévu. Merci également pour la suggestion d'économiser un octet supplémentaire! Je ne sais pas comment je l'ai raté avant. :)
MatjazGo
2

Excel, 29 octets

Utiliser la TEXTfonctionnalité d'Excel ("Convertit une valeur en texte dans un format numérique spécifique").

xen A1, yen B1

=TEXT(A1,REPT("0",MAX(1,B1)))
Wernisch
la source
Vous pouvez supprimer les )))octets de -3 en les convertissant en feuilles de calcul
Taylor Scott
2

Octave , 44 octets

@(x,y)fprintf(['%0',num2str(y+(x<0)),'d'],x)

Essayez-le en ligne!

Stewie Griffin
la source
1
Pour 31 octets
Tom Carpenter
Si les signes de début + sont autorisés pour les nombres positifs (en attendant d'entendre op si ok), cela fonctionne pour 28 .
Tom Carpenter
2

Rubis , 31 28 octets

Merci Carl d' avoir économisé 3 octets en utilisant l'interpolation.

->x,y{"%0#{y+(x<0?1:0)}d"%x}

Essayez-le en ligne!

Jérémie Bonal
la source
2
28: -> x, y {"% 0 # {y + (x <0? 1: 0)} d"% x}
Carl
2

Japt , 14 12 octets

Enregistré 2 octets grâce à @ETHproductions

s r"%d+"_ù0V

Essayez-le en ligne

Oliver
la source
Il est un peu moins cher de conserver le signe moins et de jouer avec les chiffres:
testez
@ETHproductions: Ou prenez xune chaîne de 10 octets .
Shaggy
@ETHproductions merci les gars. Je le mettrai à jour à mon retour à mon bureau.
Oliver
@Shaggy On dirait que vous avez posté votre propre réponse, je vais donc utiliser l'astuce d'ETHproduction. Merci quand même.
Oliver
Oliver, ce 10 octets est juste la solution de 12 octets de @ ETHproduction mise à niveau vers Japt 2.0a0 avec Uune chaîne nous permettant de jouer au golf sur les 2 premiers caractères.
Shaggy
2

PowerShell , 25 40 octets

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

Essayez-le en ligne!

Explication

Cela fait appel .ToString()au nombre avec une chaîne de format générée, mais le multiplie par -1, 0 ou 1 selon que $b( y) est négatif, 0 ou positif respectivement; il s'agit de gérer des yvaleurs négatives que les chaînes de format ne sont pas seules.

Cela semble nécessiter le regroupement de nombres négatifs dans une sous-déclaration ()pour que cela fonctionne, ce qui n'est qu'une bizarrerie de l'invocation lors de l'utilisation de littéraux; si passé des variables de type entier, il n'en aurait pas besoin.

briantiste
la source
Il semble que ces deux échouent quand il yest négatif.
Shaggy
@Shaggy ugh bonne capture. Suppression de la deuxième solution et correction de la première, merci!
briantist
Aïe, 15 octets! Désolé!
Shaggy
@Shaggy heh, un de ces jours, j'écrirai le langage de golf basé sur PowerShell auquel j'ai pensé. Cela m'a en fait poussé à rechercher un peu plus et à me rapprocher du démarrage, alors merci pour cela;)
briantist
2

C # 6.0, 35 octets

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

Solution alternative (51 octets)

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

C (gcc) , 45 octets

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

Essayez-le en ligne!

Explication

printf formate trois arguments:

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

%sformate la chaîne "-"+(x>=0). "-"est vraiment juste une adresse, quelque chose comme 41961441. En mémoire, cela ressemble à ceci:

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

Lorsqu'il est formaté en chaîne, C prend l'adresse (par exemple 41961441) et continue d'acquérir des caractères jusqu'à ce qu'un octet nul (0x00) soit atteint. Lorsque x est inférieur à zéro, la valeur "-"+(x>=0)a celle de l'adresse d'origine (41961441). Sinon, x>=0est 1, donc l'expression devient "-"+1, qui pointe l'octet nul après "-", qui n'affiche rien.

%0*iimprime un entier rempli avec un nombre spécifié de 0s. ydésigne ce nombre. Nous remplissons abs(x)pour éviter le négatif dans certains arguments.

Conor O'Brien
la source
1

Perl 5, 22 + 1 (- n) = 23 octets

printf"%0*d",<>+/-/,$_

Essayez-le en ligne

Nahuel Fouilleul
la source
Boucles à l'infini10,-1
Zaid
corrigé+5 bytes
Nahuel Fouilleul
a trouvé une autre solution-5 bytes
Nahuel Fouilleul
Doux. J'y travaille aussi ... restez à l'écoute
Zaid
Je l'ai réussi en 26 octets
Zaid