Relleno de ceros a la izquierda

[Phoncadiz]

Hola Foreros!

Estoy en una aplicación WebForm en VB.NET y me preguntaba si existía una función interna en la que enviándole dos números haga lo siguiente:

rellenaCeros (14,4) = 0014

Saludos!!

[erkillo]

No entiendo.... Que quieres que haga????

[Phoncadiz]

Vaya, es verdad. No he puesto lo que quería que hiciera.

14 es ún número entero cualquiera
y 4 es el número de caracteres que deseo que tenga la cadena en total.^

Así que si a la función le llega un 14 (tiene 2 caracteres numéricos) por un lado y un 4 que le indica que tiene que ser una cadena con 4 número el resultado es 0014 (4 caracteres)

Tal como pongo en el título, símplemente es rellenar de ceros a la izquierda hasta llegar al número de caracteres que indique la función. Ejemplos:

(312,8) = 00000312
(9,2) = 09
(9,1) = 9
(99,1) = error

Creo que está claro.

[Jose_minglein2]

Que yo sepa no existe, pero sería fácil implementarla

[charlytesis]

Si lo haces con unos if's y manejando los ceros, puedes realizar el relleno de ceros...

num=14
relleno=4

long=len(num)

if relleno<>long then
rellenar
end if

completalo y veras que te sale...

saludos

[RootK]

Te paso un ejemplo de como te quedaría:

Private Function GetZeros(ByVal iNum As Integer, ByVal iLimit As Integer) As String
Dim iLength As Integer = iNum.ToString.Length
Dim s As String

If iLength < iLimit Then
For i As Integer = 1 To iLimit - iLength
s += "0"
Next
s += iNum.ToString
Else
s = "Error"
End If

Return s
End Function

Y para llamarla:

Response.Write(GetZeros(312, 9))

Salu2

[Phoncadiz]

Muchas gracias a todos los que habeis participado.

Ya se que podía implementarla. Pero era para ahorrarme trabajo si es que existía o incluso si se podría realizar en una sola línea de código uniendo un par de funciones de las de toda la vida.

De todas formas... un millón de gracias!!!

[MaxExtreme]

Para quien lo quiera para VC++ o una DLL para llamar y que sea rápido, he hecho una función estilo a las ANSI-C en inline ASM...

Código:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*******************************************
* Rellena con ceros a la izquierda - MaxExtreme
*
**** Argumentos ****
* numero - Número origen al que se añadirán ceros
* destino - Puntero donde se guardará el resultado
* cifras - Cifras totales que tendrá la string destino
*
**** Devuelve ****
* ret==0	OK
* ret!=0	ERROR
******************************************/
int Rellenar(int numero, char * destino, int cifras)
{
	static char buffer[11];

	__asm
	{
		pusha

		lea edx, buffer
		push 10d
		push edx
		push numero
		call itoa
		add esp, 0Ch
		push eax
		call strlen
		pop edx

		mov ebx, destino
		mov ecx, cifras
		mov byte ptr [ebx+ecx], 0h
		sub ecx, eax
		mov edx, ecx

		cmp eax, cifras
		jg error
		je igual

ceros:		mov byte ptr [ebx+ecx-1], 30h
		loop ceros

igual:		add ebx, edx
		mov ecx, eax
		lea edx, buffer
num:		mov al, byte ptr [edx+ecx-1]
		mov byte ptr [ebx+ecx-1], al
		loop num


		popa
		mov eax, 0h
		jmp fin

error:		popa
		mov eax, 1h

fin:
	}
}



void main()
{
	// Rellenamos parte de la cadena para comprobar que se incluye el terminador \0
	char destino[100]="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

	// Rellenamos con el número 12345 con 10 cifras -> OK
	if(Rellenar(12345,destino,10)==0)	printf("%s\n",destino);
	else						printf("Error\n");

	// Rellenamos con el número 12345 con 5 cifras -> OK
	if(Rellenar(12345,destino,5)==0)	printf("%s\n",destino);
	else						printf("Error\n");

	// Rellenamos con el número 12345 con 3 cifras -> ERROR
	if(Rellenar(12345,destino,3)==0)	printf("%s\n",destino);
	else						printf("Error\n");
}

Ese ejemplo devuelve lo que se espera:

Código:

0000012345
12345
Error

No sé si se puede optimizar más, pero ahí queda como curiosidad...

** EDIT: pops sustituidos por add dado que itoa devuelve el puntero que se le pasa y por lo tanto lo tenemos en eax para hacer push a strlen sin usar edx - Eternal Idol