Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

**Khanysha**

Hallo zusammen,

Ich lese hier schon eine Weile mit und habe nun die Sufu ordentlich rangenommen, aber entweder nehme ich nicht die richtigen Schlagworte oder es hatte noch keiner das Problem.

Das Problem ist folgendes, ich baue Unittests und habe nun in diesen Tests einen Fehler entdeckt der auf kurz oder lang doch recht kritisch werden kann. Die Funktion die getestet wird konvertiert Spaltennamen in Excel, also A, B, C.. usw, bis Z ist alles tutti. Dann kommen wir aber zu AA, AB, AC.. und der Fehler tritt dann bei AZ auf. Also Spalte 52 müsste (und ist es auch im Excel) AZ sein aber der Debugger sagt: Es ist B. Spalte 53 ist dann aber wie gewollt BA. Gleiches tritt dann natürlich auch bei BZ auf, BZ ist dann B und CZ ist C. Das ist wie bei Nummerierungen im WinExplorer die Zahlen 01, 10, 11 werden zusammen geschoben, ist ja überall ne eins drin(So fühlt es sich zumindest an).

Nun versuche ich eine Lösung zu finden, wie man der Funktion erklären kann das Spalte 52 nicht B sonder AZ ist. Meine Erste Überlegung war: Z dranhängen, funktioniert so aber nicht da er aus dem AZ ja B macht. Dann ging die Überlegung in die Richtung das ich jede 26. Spalte nehme (ab einschließlich 52) und sage das ist nicht B sondern AZ, das ist nicht C sonder BZ und so weiter... (Ich bin mir dessen bewusst das man meinem Gedanken kann schlecht folgen könnte, weiß es aber im moment nicht besser auszudrücken).

Ich weiß nicht von welcher Seite ich das Pferd aufsatteln soll

In welche Richtung muss ich denken, damit ich einen Weg finde dem Compiler zu sagen das die Spaltenübergänge ein Z haben und nicht den zuletzt verwendetetn Buchstaben?

Hier noch die Funktion:

zusammenfalten · markieren

Delphi-Quellcode:

			function MS_EXCEL_ConvertColumn(AColumn: Integer): String;

begin

  Result := '';

  while AColumn > 0 do

  begin

    if AColumn <= 26 then

    begin

      Result := Result + Chr(AColumn + 64);

      Dec(AColumn, 26);

    end

    else

    begin

      Result := Result + Chr((AColumn -27) div 26 + 65);      // Mit dieser umgeschrieben Zeile habe ich schon mal bei 'AZ' nur A statt B, jetzt fehlt mir noch das Z dahinter

      AColumn := AColumn mod 26;

    end;

  end;

Diese Funktion wurde nicht von mir geschrieben, ich teste sie nur und suche nach Fehlern, will sie aber nun abändern da Fehler keineswegs ignoriert werden sollten

LG

**Jumpy**

Im Falle von 52 und aller anderen vielfachen von 26 ist AColumn mod 26 = 0 und das Ganze bricht ab. Mit der folgenden Änderung würde es glaub ich funktionieren:

zusammenfalten · markieren

Delphi-Quellcode:

			function MS_EXCEL_ConvertColumn(AColumn: Integer): String;

begin

  Result := '';

  while AColumn > 0 do

  begin

    if AColumn <= 26 then

    begin

      Result := Result + Chr(AColumn + 64);

      Dec(AColumn, 26);

    end

    else

    begin

      Result := Result + Chr((AColumn -27) div 26 + 65); // Mit dieser umgeschrieben Zeile habe ich schon mal bei 'AZ' nur A statt B, jetzt fehlt mir noch das Z dahinter

      AColumn := AColumn mod 26;

      if AColumn=0 then

        Result:=Result+'Z';

    end;

  end;

Hier bitte aber bedenken, dass das nur bis Spalte ZZ funktioniert (=27*26 Spalten). Excel geht aber mittlerweile bis XFD, d.h. wenn da mal Gefahr besteht, das ihr so richtig viele Spalten braucht, muss die Funktion nochmal verbessert werden.

Suchst Du sowas?

zusammenfalten · markieren

Delphi-Quellcode:

			program ExcelSpalten;

var

        i : Integer;

        k : Integer;

        m : Integer;

        s : String;

begin

  for i := 1 to 256 do begin

    s := '';

    k := i;

    while k > 26 do begin

      m := k mod 26;

      if m = 0 then begin

        s := Chr(m + 64 + 26) + s;

        k := (k div 26) - 1;

      end else begin

        s := Chr(m + 64) + s;

        k := k div 26;

      end;

    end;

    s := Chr(k + 64) + s;

    WriteLn(Format('i = %.3d -> Spaltenname = %s - (k = %.3d)',[i,s,k]));

  end;

end.

(Ist in Pascalscript geschrieben, Syntax für Delphi muss ggfls. angepasst werden.)

Rauskommen tut dieses:

markieren

Code:

			i = 001 -> Spaltenname = A - (k = 001)

i = 002 -> Spaltenname = B - (k = 002)

i = 003 -> Spaltenname = C - (k = 003)

i = 004 -> Spaltenname = D - (k = 004)

i = 005 -> Spaltenname = E - (k = 005)

i = 006 -> Spaltenname = F - (k = 006)

i = 007 -> Spaltenname = G - (k = 007)

i = 008 -> Spaltenname = H - (k = 008)

i = 009 -> Spaltenname = I - (k = 009)

i = 010 -> Spaltenname = J - (k = 010)

i = 011 -> Spaltenname = K - (k = 011)

i = 012 -> Spaltenname = L - (k = 012)

i = 013 -> Spaltenname = M - (k = 013)

i = 014 -> Spaltenname = N - (k = 014)

i = 015 -> Spaltenname = O - (k = 015)

i = 016 -> Spaltenname = P - (k = 016)

i = 017 -> Spaltenname = Q - (k = 017)

i = 018 -> Spaltenname = R - (k = 018)

i = 019 -> Spaltenname = S - (k = 019)

i = 020 -> Spaltenname = T - (k = 020)

i = 021 -> Spaltenname = U - (k = 021)

i = 022 -> Spaltenname = V - (k = 022)

i = 023 -> Spaltenname = W - (k = 023)

i = 024 -> Spaltenname = X - (k = 024)

i = 025 -> Spaltenname = Y - (k = 025)

i = 026 -> Spaltenname = Z - (k = 026)

i = 027 -> Spaltenname = AA - (k = 001)

i = 028 -> Spaltenname = AB - (k = 001)

i = 029 -> Spaltenname = AC - (k = 001)

i = 030 -> Spaltenname = AD - (k = 001)

i = 031 -> Spaltenname = AE - (k = 001)

i = 032 -> Spaltenname = AF - (k = 001)

i = 033 -> Spaltenname = AG - (k = 001)

i = 034 -> Spaltenname = AH - (k = 001)

i = 035 -> Spaltenname = AI - (k = 001)

i = 036 -> Spaltenname = AJ - (k = 001)

i = 037 -> Spaltenname = AK - (k = 001)

i = 038 -> Spaltenname = AL - (k = 001)

i = 039 -> Spaltenname = AM - (k = 001)

i = 040 -> Spaltenname = AN - (k = 001)

i = 041 -> Spaltenname = AO - (k = 001)

i = 042 -> Spaltenname = AP - (k = 001)

i = 043 -> Spaltenname = AQ - (k = 001)

i = 044 -> Spaltenname = AR - (k = 001)

i = 045 -> Spaltenname = AS - (k = 001)

i = 046 -> Spaltenname = AT - (k = 001)

i = 047 -> Spaltenname = AU - (k = 001)

i = 048 -> Spaltenname = AV - (k = 001)

i = 049 -> Spaltenname = AW - (k = 001)

i = 050 -> Spaltenname = AX - (k = 001)

i = 051 -> Spaltenname = AY - (k = 001)

i = 052 -> Spaltenname = AZ - (k = 001)

i = 053 -> Spaltenname = BA - (k = 002)

i = 054 -> Spaltenname = BB - (k = 002)

i = 055 -> Spaltenname = BC - (k = 002)

i = 056 -> Spaltenname = BD - (k = 002)

i = 057 -> Spaltenname = BE - (k = 002)

i = 058 -> Spaltenname = BF - (k = 002)

i = 059 -> Spaltenname = BG - (k = 002)

i = 060 -> Spaltenname = BH - (k = 002)

i = 061 -> Spaltenname = BI - (k = 002)

i = 062 -> Spaltenname = BJ - (k = 002)

i = 063 -> Spaltenname = BK - (k = 002)

i = 064 -> Spaltenname = BL - (k = 002)

i = 065 -> Spaltenname = BM - (k = 002)

i = 066 -> Spaltenname = BN - (k = 002)

i = 067 -> Spaltenname = BO - (k = 002)

i = 068 -> Spaltenname = BP - (k = 002)

i = 069 -> Spaltenname = BQ - (k = 002)

i = 070 -> Spaltenname = BR - (k = 002)

i = 071 -> Spaltenname = BS - (k = 002)

i = 072 -> Spaltenname = BT - (k = 002)

i = 073 -> Spaltenname = BU - (k = 002)

i = 074 -> Spaltenname = BV - (k = 002)

i = 075 -> Spaltenname = BW - (k = 002)

i = 076 -> Spaltenname = BX - (k = 002)

i = 077 -> Spaltenname = BY - (k = 002)

i = 078 -> Spaltenname = BZ - (k = 002)

i = 079 -> Spaltenname = CA - (k = 003)

i = 080 -> Spaltenname = CB - (k = 003)

i = 081 -> Spaltenname = CC - (k = 003)

i = 082 -> Spaltenname = CD - (k = 003)

i = 083 -> Spaltenname = CE - (k = 003)

i = 084 -> Spaltenname = CF - (k = 003)

i = 085 -> Spaltenname = CG - (k = 003)

i = 086 -> Spaltenname = CH - (k = 003)

i = 087 -> Spaltenname = CI - (k = 003)

i = 088 -> Spaltenname = CJ - (k = 003)

i = 089 -> Spaltenname = CK - (k = 003)

i = 090 -> Spaltenname = CL - (k = 003)

i = 091 -> Spaltenname = CM - (k = 003)

i = 092 -> Spaltenname = CN - (k = 003)

i = 093 -> Spaltenname = CO - (k = 003)

i = 094 -> Spaltenname = CP - (k = 003)

i = 095 -> Spaltenname = CQ - (k = 003)

i = 096 -> Spaltenname = CR - (k = 003)

i = 097 -> Spaltenname = CS - (k = 003)

i = 098 -> Spaltenname = CT - (k = 003)

i = 099 -> Spaltenname = CU - (k = 003)

i = 100 -> Spaltenname = CV - (k = 003)

i = 101 -> Spaltenname = CW - (k = 003)

i = 102 -> Spaltenname = CX - (k = 003)

i = 103 -> Spaltenname = CY - (k = 003)

i = 104 -> Spaltenname = CZ - (k = 003)

i = 105 -> Spaltenname = DA - (k = 004)

i = 106 -> Spaltenname = DB - (k = 004)

i = 107 -> Spaltenname = DC - (k = 004)

i = 108 -> Spaltenname = DD - (k = 004)

i = 109 -> Spaltenname = DE - (k = 004)

i = 110 -> Spaltenname = DF - (k = 004)

i = 111 -> Spaltenname = DG - (k = 004)

i = 112 -> Spaltenname = DH - (k = 004)

i = 113 -> Spaltenname = DI - (k = 004)

i = 114 -> Spaltenname = DJ - (k = 004)

i = 115 -> Spaltenname = DK - (k = 004)

i = 116 -> Spaltenname = DL - (k = 004)

i = 117 -> Spaltenname = DM - (k = 004)

i = 118 -> Spaltenname = DN - (k = 004)

i = 119 -> Spaltenname = DO - (k = 004)

i = 120 -> Spaltenname = DP - (k = 004)

i = 121 -> Spaltenname = DQ - (k = 004)

i = 122 -> Spaltenname = DR - (k = 004)

i = 123 -> Spaltenname = DS - (k = 004)

i = 124 -> Spaltenname = DT - (k = 004)

i = 125 -> Spaltenname = DU - (k = 004)

i = 126 -> Spaltenname = DV - (k = 004)

i = 127 -> Spaltenname = DW - (k = 004)

i = 128 -> Spaltenname = DX - (k = 004)

i = 129 -> Spaltenname = DY - (k = 004)

i = 130 -> Spaltenname = DZ - (k = 004)

i = 131 -> Spaltenname = EA - (k = 005)

i = 132 -> Spaltenname = EB - (k = 005)

i = 133 -> Spaltenname = EC - (k = 005)

i = 134 -> Spaltenname = ED - (k = 005)

i = 135 -> Spaltenname = EE - (k = 005)

i = 136 -> Spaltenname = EF - (k = 005)

i = 137 -> Spaltenname = EG - (k = 005)

i = 138 -> Spaltenname = EH - (k = 005)

i = 139 -> Spaltenname = EI - (k = 005)

i = 140 -> Spaltenname = EJ - (k = 005)

i = 141 -> Spaltenname = EK - (k = 005)

i = 142 -> Spaltenname = EL - (k = 005)

i = 143 -> Spaltenname = EM - (k = 005)

i = 144 -> Spaltenname = EN - (k = 005)

i = 145 -> Spaltenname = EO - (k = 005)

i = 146 -> Spaltenname = EP - (k = 005)

i = 147 -> Spaltenname = EQ - (k = 005)

i = 148 -> Spaltenname = ER - (k = 005)

i = 149 -> Spaltenname = ES - (k = 005)

i = 150 -> Spaltenname = ET - (k = 005)

i = 151 -> Spaltenname = EU - (k = 005)

i = 152 -> Spaltenname = EV - (k = 005)

i = 153 -> Spaltenname = EW - (k = 005)

i = 154 -> Spaltenname = EX - (k = 005)

i = 155 -> Spaltenname = EY - (k = 005)

i = 156 -> Spaltenname = EZ - (k = 005)

i = 157 -> Spaltenname = FA - (k = 006)

i = 158 -> Spaltenname = FB - (k = 006)

i = 159 -> Spaltenname = FC - (k = 006)

i = 160 -> Spaltenname = FD - (k = 006)

i = 161 -> Spaltenname = FE - (k = 006)

i = 162 -> Spaltenname = FF - (k = 006)

i = 163 -> Spaltenname = FG - (k = 006)

i = 164 -> Spaltenname = FH - (k = 006)

i = 165 -> Spaltenname = FI - (k = 006)

i = 166 -> Spaltenname = FJ - (k = 006)

i = 167 -> Spaltenname = FK - (k = 006)

i = 168 -> Spaltenname = FL - (k = 006)

i = 169 -> Spaltenname = FM - (k = 006)

i = 170 -> Spaltenname = FN - (k = 006)

i = 171 -> Spaltenname = FO - (k = 006)

i = 172 -> Spaltenname = FP - (k = 006)

i = 173 -> Spaltenname = FQ - (k = 006)

i = 174 -> Spaltenname = FR - (k = 006)

i = 175 -> Spaltenname = FS - (k = 006)

i = 176 -> Spaltenname = FT - (k = 006)

i = 177 -> Spaltenname = FU - (k = 006)

i = 178 -> Spaltenname = FV - (k = 006)

i = 179 -> Spaltenname = FW - (k = 006)

i = 180 -> Spaltenname = FX - (k = 006)

i = 181 -> Spaltenname = FY - (k = 006)

i = 182 -> Spaltenname = FZ - (k = 006)

i = 183 -> Spaltenname = GA - (k = 007)

i = 184 -> Spaltenname = GB - (k = 007)

i = 185 -> Spaltenname = GC - (k = 007)

i = 186 -> Spaltenname = GD - (k = 007)

i = 187 -> Spaltenname = GE - (k = 007)

i = 188 -> Spaltenname = GF - (k = 007)

i = 189 -> Spaltenname = GG - (k = 007)

i = 190 -> Spaltenname = GH - (k = 007)

i = 191 -> Spaltenname = GI - (k = 007)

i = 192 -> Spaltenname = GJ - (k = 007)

i = 193 -> Spaltenname = GK - (k = 007)

i = 194 -> Spaltenname = GL - (k = 007)

i = 195 -> Spaltenname = GM - (k = 007)

i = 196 -> Spaltenname = GN - (k = 007)

i = 197 -> Spaltenname = GO - (k = 007)

i = 198 -> Spaltenname = GP - (k = 007)

i = 199 -> Spaltenname = GQ - (k = 007)

i = 200 -> Spaltenname = GR - (k = 007)

i = 201 -> Spaltenname = GS - (k = 007)

i = 202 -> Spaltenname = GT - (k = 007)

i = 203 -> Spaltenname = GU - (k = 007)

i = 204 -> Spaltenname = GV - (k = 007)

i = 205 -> Spaltenname = GW - (k = 007)

i = 206 -> Spaltenname = GX - (k = 007)

i = 207 -> Spaltenname = GY - (k = 007)

i = 208 -> Spaltenname = GZ - (k = 007)

i = 209 -> Spaltenname = HA - (k = 008)

i = 210 -> Spaltenname = HB - (k = 008)

i = 211 -> Spaltenname = HC - (k = 008)

i = 212 -> Spaltenname = HD - (k = 008)

i = 213 -> Spaltenname = HE - (k = 008)

i = 214 -> Spaltenname = HF - (k = 008)

i = 215 -> Spaltenname = HG - (k = 008)

i = 216 -> Spaltenname = HH - (k = 008)

i = 217 -> Spaltenname = HI - (k = 008)

i = 218 -> Spaltenname = HJ - (k = 008)

i = 219 -> Spaltenname = HK - (k = 008)

i = 220 -> Spaltenname = HL - (k = 008)

i = 221 -> Spaltenname = HM - (k = 008)

i = 222 -> Spaltenname = HN - (k = 008)

i = 223 -> Spaltenname = HO - (k = 008)

i = 224 -> Spaltenname = HP - (k = 008)

i = 225 -> Spaltenname = HQ - (k = 008)

i = 226 -> Spaltenname = HR - (k = 008)

i = 227 -> Spaltenname = HS - (k = 008)

i = 228 -> Spaltenname = HT - (k = 008)

i = 229 -> Spaltenname = HU - (k = 008)

i = 230 -> Spaltenname = HV - (k = 008)

i = 231 -> Spaltenname = HW - (k = 008)

i = 232 -> Spaltenname = HX - (k = 008)

i = 233 -> Spaltenname = HY - (k = 008)

i = 234 -> Spaltenname = HZ - (k = 008)

i = 235 -> Spaltenname = IA - (k = 009)

i = 236 -> Spaltenname = IB - (k = 009)

i = 237 -> Spaltenname = IC - (k = 009)

i = 238 -> Spaltenname = ID - (k = 009)

i = 239 -> Spaltenname = IE - (k = 009)

i = 240 -> Spaltenname = IF - (k = 009)

i = 241 -> Spaltenname = IG - (k = 009)

i = 242 -> Spaltenname = IH - (k = 009)

i = 243 -> Spaltenname = II - (k = 009)

i = 244 -> Spaltenname = IJ - (k = 009)

i = 245 -> Spaltenname = IK - (k = 009)

i = 246 -> Spaltenname = IL - (k = 009)

i = 247 -> Spaltenname = IM - (k = 009)

i = 248 -> Spaltenname = IN - (k = 009)

i = 249 -> Spaltenname = IO - (k = 009)

i = 250 -> Spaltenname = IP - (k = 009)

i = 251 -> Spaltenname = IQ - (k = 009)

i = 252 -> Spaltenname = IR - (k = 009)

i = 253 -> Spaltenname = IS - (k = 009)

i = 254 -> Spaltenname = IT - (k = 009)

i = 255 -> Spaltenname = IU - (k = 009)

i = 256 -> Spaltenname = IV - (k = 009)

Mit 'ner Funktion könnte es so aussehen:

zusammenfalten · markieren

Delphi-Quellcode:

			program ExcelSpalten;

function MS_EXCEL_ConvertColumn(AColumn: Integer): String;

var

        k : Integer;

        m : Integer;

begin

  Result := '';

  k := AColumn;

  while k > 26 do begin

    m := k mod 26;

    if m = 0 then begin

      Result := Chr(m + 64 + 26) + Result;

      k := (k div 26) - 1;

    end else begin

      Result := Chr(m + 64) + Result;

      k := k div 26;

    end;

  end;

  Result := Chr(k + 64) + Result;

end;

var

        i : Integer;

begin

  For i := 1 to 25600 do begin

    WriteLn(MS_EXCEL_ConvertColumn(i));

  end;

end.

**Khanysha**

Danke, für die schnelle, aufwendige Antwort, auf den ersten Blick sieht das ganz gut aus, muss aber nochmal genauer schauen um deine Variante nun zu verstehen, bin nun 2. Lehrjahr da stehe ich manchmal wie n Ochs vor'm Berg

Ich friemel mal n bissl rum und melde mich wenn ich wieder stolper oder es dann so funzt wie ich es gern hätte.

Danke

Edit: OH du gute Güt! Es funtioniert! Bissl zurecht schieben und meine Spalten haben nun ein Z an dem Buchstaben, wenn sie am "Ende" angekommen sind! Vielen Dank.
Edit, die 2.: Ich habe noch 'ne Zeile reingeschrieben die den Negativzahl-Fall abfängt, es sieht so aus, als wenn nun so funktioniert wie sie sollte!

Danke

LG

**Khanysha**

Zitat von Jumpy:

Im Falle von 52 und aller anderen vielfachen von 26 ist AColumn mod 26 = 0 und das Ganze bricht ab. Mit der folgenden Änderung würde es glaub ich funktionieren:

zusammenfalten · markieren

Delphi-Quellcode:

			function MS_EXCEL_ConvertColumn(AColumn: Integer): String;

begin

  Result := '';

  while AColumn > 0 do

  begin

    if AColumn <= 26 then

    begin

      Result := Result + Chr(AColumn + 64);

      Dec(AColumn, 26);

    end

    else

    begin

      Result := Result + Chr((AColumn -27) div 26 + 65); // Mit dieser umgeschrieben Zeile habe ich schon mal bei 'AZ' nur A statt B, jetzt fehlt mir noch das Z dahinter

      AColumn := AColumn mod 26;

      if AColumn=0 then

        Result:=Result+'Z';

    end;

  end;

Hier bitte aber bedenken, dass das nur bis Spalte ZZ funktioniert (=27*26 Spalten). Excel geht aber mittlerweile bis XFD, d.h. wenn da mal Gefahr besteht, das ihr so richtig viele Spalten braucht, muss die Funktion nochmal verbessert werden.

Jetzt war ich so tief in meinen Hirnwindungen das ich das total überlesen haben, die Sache mit dem Z dranhängen hatte ich auch versucht, aber ich habe anscheinend nicht den richtigen Weg genommen, schaue mir das nochmal genauer an. Dir natürlich auch Danke für die Antwort.

LG

Es hat mir keine Ruhe gelassen, deshalb noch 'ne kürzere Variant

zusammenfalten · markieren

Delphi-Quellcode:

			program ExcelSpalten;

function MS_EXCEL_ConvertColumn(AColumn: Integer): String;

begin

  if (AColumn < 1) or (AColumn > 16384) then begin

    Result := Format('ungültige Spaltenposition (%d)',[AColumn]);

  end else while AColumn > 0 do begin

    if AColumn mod 26 = 0 then begin

      Result  := 'Z' + Result;

      AColumn := AColumn - 1;

    end else begin

      Result  := Chr((AColumn mod 26) + 64) + Result;

    end;

    AColumn := AColumn div 26;

  end;

end;

var

        i : Integer;

begin

  // Spaltenbezeichnungen können von 1 -> A bis 16384 -> XFD vergeben werden.

  for i := 0 to 16385 do WriteLn(MS_EXCEL_ConvertColumn(i));

end.

**Khanysha**

Zitat von nahpets:

Es hat mir keine Ruhe gelassen, deshalb noch 'ne kürzere Variant

zusammenfalten · markieren

Delphi-Quellcode:

			program ExcelSpalten;

function MS_EXCEL_ConvertColumn(AColumn: Integer): String;

begin

  if (AColumn < 1) or (AColumn > 16384) then begin

    Result := Format('ungültige Spaltenposition (%d)',[AColumn]);

  end else while AColumn > 0 do begin

    if AColumn mod 26 = 0 then begin

      Result  := 'Z' + Result;

      AColumn := AColumn - 1;

    end else begin

      Result  := Chr((AColumn mod 26) + 64) + Result;

    end;

    AColumn := AColumn div 26;

  end;

end;

var

        i : Integer;

begin

  // Spaltenbezeichnungen können von 1 -> A bis 16384 -> XFD vergeben werden.

  for i := 0 to 16385 do WriteLn(MS_EXCEL_ConvertColumn(i));

end.

So in dieser Art hab ich es nun auch

Habe gestern noch den Fall von Negativzahlen und MaxSpalten abgefangen, ich habe zwar keine Ahnung wer so eine breite Tabelle hat aber man weiß ja nie. Darum mache ich ja die Unittests, um auf Grenzen und Fehlerfälle zu prüfen

̶ ̶̶m̶̶u̶̶s̶̶s̶̶ ̶̶s̶̶t̶̶a̶̶t̶̶t̶̶ ̶̶d̶̶e̶̶m̶̶ ̶̶o̶̶r̶̶ ̶̶n̶̶i̶̶c̶̶h̶̶t̶̶ ̶̶e̶̶i̶̶n̶̶ ̶̶u̶̶n̶̶d̶̶ ̶̶r̶̶e̶̶i̶̶n̶̶?̶̶ ̶̶w̶̶e̶̶i̶̶l̶̶ ̶̶i̶̶n̶̶ ̶̶d̶̶e̶̶i̶̶n̶̶e̶̶m̶̶ ̶̶f̶̶a̶̶l̶̶l̶̶ ̶̶k̶̶a̶̶n̶̶n̶̶ ̶̶i̶̶c̶̶h̶̶ ̶̶d̶̶o̶̶c̶̶h̶̶ ̶̶n̶̶e̶̶g̶̶a̶̶t̶̶i̶̶v̶̶e̶̶ ̶̶z̶̶a̶̶h̶̶l̶̶e̶̶n̶̶ ̶̶e̶̶i̶̶n̶̶t̶̶r̶̶a̶̶g̶̶e̶̶n̶̶ ̶̶o̶̶d̶̶e̶̶r̶̶?̶̶ ̶̶d̶̶3̶̶e̶̶n̶̶k̶̶e̶̶ ̶̶i̶̶c̶̶h̶̶ ̶̶d̶̶a̶̶ ̶̶n̶̶u̶̶n̶̶ ̶̶i̶̶n̶̶ ̶̶d̶̶i̶̶e̶̶ ̶̶f̶̶a̶̶l̶̶s̶̶c̶̶h̶̶e̶̶ ̶̶r̶̶i̶̶c̶̶h̶̶t̶̶u̶̶n̶̶g̶̶,̶̶ ̶̶w̶̶o̶̶r̶̶t̶̶w̶̶ö̶̶r̶̶t̶̶l̶̶i̶̶c̶̶h̶̶?̶

Vergiss das mit dem Und... hatte noch keinen Kaffee und habe die nächste Zeile beim 3.Mal erst realisiert.
LG

Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

AW: Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

AW: Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

AW: Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

AW: Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

AW: Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

AW: Excel,Spaltenkonvertierung, Übergang zu nächstem Buchstaben

Forumregeln