masque tous les chiffres sauf les 6 premiers et les 4 derniers chiffres d'une chaîne( de longueur variable )

Je voudrais faire quelque chose comme ceci (pseudo C# - prendre comme idée de construire).

Code non testé à l'avance...

string MaskDigits(string input)
{
    //take first 6 characters
    string firstPart = input.Substring(0, 6);

    //take last 4 characters
    int len = input.Length;
    string lastPart = input.Substring(len - 4, 4);

    //take the middle part (XXXXXXXXX)
    int middlePartLenght = input.Substring(6, len - 4).Count();
    string middlePart = new String('X', 5);

    return firstPart + middlePart + lastPart;
}

OriginalL'auteur

Possibles de mise en œuvre (acccepts varios formats par exemple, les nombres peuvent être divisés en groupes, etc.):

private static String MaskedNumber(String source) {
  StringBuilder sb = new StringBuilder(source);

  const int skipLeft = 6;
  const int skipRight = 4;

  int left = -1;

  for (int i = 0, c = 0; i < sb.Length; ++i) {
    if (Char.IsDigit(sb[i])) {
      c += 1;

      if (c > skipLeft) {
        left = i;

        break;
      }
    }
  }

  for (int i = sb.Length - 1, c = 0; i >= left; --i)
    if (Char.IsDigit(sb[i])) {
      c += 1;

      if (c > skipRight)
        sb[i] = 'X';
    }

  return sb.ToString();
}

//Tests 

  //3456-12XX-XXXX-1234
  Console.Write(MaskedNumber("3456-1234-3456-1234"));
  //3456123XXXXX1234
  Console.Write(MaskedNumber("3456123434561234"));

cette mise en œuvre uniquement pour masquer les chiffres et préserver le format.

OriginalL'auteur

Je suis sûr qu'il ya une façon plus propre de le faire:

int currentChar = 0;
string maskable = "11111144441111";

string masked = maskable;
int length = masked.Length;

int startMaskPoint = 6;
int endMaskPoint = length - 4 - startMaskPoint;

masked = masked.Remove(startMaskPoint, endMaskPoint);

int numRemoved = length - masked.Length;
string Mask = "";
while (numRemoved != 0)
{
    Mask = Mask + "#";
    numRemoved--;
}

masked = masked.Insert(startMaskPoint, Mask);
string returnableString = masked;
while (length > 4)
{
    returnableString = returnableString.Insert(currentChar + 4, " ");
    currentChar = currentChar + 5;
    length = length - 4;
}

OriginalL'auteur

Beaucoup de solutions d'analyse l'entrée en plusieurs fois.
Ci-dessous, je présente une solution qui analyse les saisies qu'une seule fois.
Mais je n'ai pas d'expérience en C#, donc la fonction est écrite dans le Schéma.

La fonction est divisé en deux:

(1) visite de la première 6 analyse les six premiers caractères et les concatène pour le reste du calcul.
Lors de la visite de la première 6 a analysé les six premiers caractères, il appelle à la visite de repos.

(2) visite de repos exploite le fait que nous pouvons retarder de calcul, jusqu'à ce que nous avons acquis plus de connaissances.
Dans ce cas, nous nous attendre pour déterminer si l'élément de la liste doit être affichée jusqu'à ce que nous savons combien de personnages sont à gauche.

(define (mask xs)
  (letrec ([visit-first-6 (lambda (xs chars-parsed)
                            (cond
                              [(null? xs)
                               ;; Shorter than 6 characters.
                               '()]
                              [(< chars-parsed 6)
                               ;; Still parsing the first 6 characters
                               (cons (car xs)
                                     (visit-first-6 (cdr xs)
                                                    (1+ chars-parsed)))]
                              [else
                               ;; The first 6 characters have been parsed.
                               (visit-rest xs
                                           (lambda (ys chars-left)
                                             ys))]))]
           [visit-rest (lambda (xs k)
                         (if (null? xs)
                             ;; End of input
                             (k '() 0)
                             ;; Parsing rest of the input
                             (visit-rest (cdr xs)
                                         (lambda (rest chars-left)
                                           (if (< chars-left 4)
                                               ;; Show the last 4 characters
                                               (k (cons (car xs) rest)
                                                  (1+ chars-left))
                                               ;; Don't show the middle characters
                                               (k (cons "X"
                                                        rest)
                                                  (1+ chars-left)))))))])
    (visit-first-6 xs
                   0)))

L'exécution de masque dans la Petite Chez interpréteur Scheme

> (mask '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18))
(1 2 3 4 5 6 "X" "X" "X" "X" "X" "X" "X" "X" 15 16 17 18)
> (mask '())
()
> (mask '(1 2 3 4))
(1 2 3 4)
> (mask '(1 2 3 4 5))
(1 2 3 4 5)
> (mask '(1 2 3 4 5 6 7 8 9))
(1 2 3 4 5 6 7 8 9)
> (mask '(1 2 3 4 5 6 7 8 9 10))
(1 2 3 4 5 6 7 8 9 10)
> (mask '(1 2 3 4 5 6 7 8 9 10 11))
(1 2 3 4 5 6 "X" 8 9 10 11)

NB. Je l'ai vu comme un drôle d'exercice et j'ai pensé que je pourrais aussi bien le partager.
Yannick Meeus a déjà fourni une facilement compréhensible solution.
Donc, cela ne sert que pour les intéressés.

OriginalL'auteur