Creio que não entendi corretamente o que deseja, mas utilizar o padrão RC (linha/coluna) não altera em nada o que descreveu acima, e creio eu torna mais complicado pois nesse padrão a posição relativa da formula pode afetar a declaração.
Para o Address pode-se utilizar em adendo linha ou coluna absoluta=False -->
Cells(1, 48).Address(RowAbsolute:=False, ColumnAbsolute:=False) retorna AV1
ou tambem
Cells(1, 48).Address(ReferenceStyle:=xlR1C1) retorna R1C48
ou
Cells(1, 48).Address(ReferenceStyle:=xlR1C1, RowAbsolute:=False, ColumnAbsolute:=False) retorna RC[47]

Pergunta: Realmente é necessário "passar" a formula à planilha, passar o valor não fica mais simples?

ola.

já tenho uma que faz por valores, usei array e é quase instantânea.

infelizmente tenho que fazer por formulas para conseguir oq eu quero

as formulas vão ser aplicadas por macro para se ter varias ranges diferentes de setores diferentes
outras macros vão deslocar os setores originais
e será feita a analise do resultado para se conseguir o padrão buscado
estou tentando fazer automático,
as macros vão descolar a planilha de varias maneiras diferentes
para capturar os valores requeridos

já fiz formulas dinâmicas que são aplicadas por macro, até as formatações são e condicionais são assim

estou tentando dinamizar a criação das formulas tbm , mas ficou lento
talvez não seja viavel...
se não dé vou fazer o para que ao se fazer o deslocamentos requerido se acione a macro para realocar os valores

é... pelo visto vai ser brabo

Reinaldo, só vc mesmo para tentar responder as minhas duvidas

att

pensei num jeito de fazer "acho"

um loop para montar todas as letras de colunas envolvidas e montar dentro de um Array

como quantidade das letras são mínimas "maximo de 140"
não vai afetar a performance para quando entrar no loop grande .

um array bidimensional com ARR(Setores,Colunas) deve resolver

vem vou tentar aqui

att.

é, não resolveu muita coisa.
deve ser na aplicação das formulas na planilha que deve estar gerando a demora

mesmo com
Application.ScreenUpdating = False
Application.Calculation = xlCalculationManual

e com Cells(L, cd + Cs).formula = "=if(" & Cg(sto, Cs) & Lg & "<>""""," & Cg(sto, Cs) & Lg & ","""")"
demora mais ainda por causa da conversão

não sei se dá, mas vou tentar gravar as formulas em um array e aplicar de uma só vez na planilha.

E se vc trocar essas linhas:

Cg(sto) = Cells(1, Cx(sto) + Cs).Address' --<<--pega NUMERO de coluna e transforma em endereço de celula "G1"
Cg(sto) = Mid(Cg(sto), InStr(Cg(sto), "$") + 1, InStr(2, Cg(sto), "$") - 2) ' --<<--pega o endereço de celula e transforma em LETRA de coluna

Cells(L, cd + Cs).FormulaLocal = "=SE(" & Cg(sto) & Lg & "<>"""";" & Cg(sto) & Lg & ";"""")" '--<<-- monta a formula

Por estas:

Cg(sto) = Cells(Lg, Cx(sto) + Cs).Address
Cells(L, cd + Cs).FormulaLocal = "=SE(" & Cg(sto) & "<>"""";" & Cg(sto) & ";"""")" '--<<-- monta a formula

como as ideias passam batidas ...

mas infelizmente não é a troca de letras e números de colunas que deixa a macro lenta

é a aplicação da formula na planilha celula por celula

acho que mesmo com
Application.Calculation = xlCalculationManual
o exel ainda faz alguma verificação

já tinha reparado nisso com outras macro, que aplicadas em areas sem formatação condicional ou formulas ficaram muito mais rápidas,

e com arrays o ganho de performance é monstruoso
mas não sei se dá para escrever formulas em array e passa-las para a planilha

mas valeu pela dica

era a aplicação da formula na planilha mesmo
agora está praticamente instantâneo a aplicação, mesmo aplicando 3000 linhas *10 colunas de formulas
antes demorava até para 30 linhas

    lto = 1000
    stn = scn * lto
ReDim coluno(1 To stn, Ma)
    Lg = Lf1: L = stn
    For gfd = 1 To lto
        For sto = 1 To scn
            For Cs = 0 To Ma
               coluno(L, Cs) = "=SE(" & Cg(sto, Cs) & Lg & "<>"""";" & Cg(sto, Cs) & Lg & ";"""")"
            Next
            L = L - 1
        Next
        Lg = Lg - 1
    Next
Range(Ti & Lf1 - stn + 1, Fc & Lf1).FormulaLocal = coluno

agora tenho que adaptar as formulas

att.