Saber se uma sequencia de Numeros/caracteres, tem repetentes

[informais]

Olá amigos, tudo bem

Preciso ler uma (string/Texto) que na verdade está armazenando dezenas, e que está separada por PIPE
Preciso saber quantas vezes e quais números repetem nela, separados por PIPE |

Exemplo veja a String/texto

04|09|16|23|39|43|80|85|94|99 nenhuma dezena se repete
30|30|30|30|30|01|01|01|01|01 Já nessa o 30 e 01 Repete várias vezes
04|04|16|23|39|43|80|85|94|99 04 - 2 Vezes
etc..

Preciso ter um retorno de qual(ais)dezena se Repetem

Exemplo a primeira seria assim Não tem Repetidos

Espero que tenham entendido

Essa informação está dentro de uma tabela campo Char, cada um em uma linha da tabela

Assim que fica no banco de dados

17|20|22|27|30|35|41|42|75|95
71|16|25|34|70|27|80|43|61|06
04|12|17|29|39|43|48|67|69|81
95|94|98|97|08|77|83|84|85|20
01|01|01|01|01|01|01|01|01|01
04|06|08|12|17|28|29|39|79|86
11|18|23|27|39|43|49|74|77|84
27|95|06|35|61|56|98|49|17|01
43|16|74|56|84|08|34|55|69|06
01|06|09|16|35|49|62|70|89|99
18|17|38|98|06|02|43|22|49|27
27|06|32|35|75|81|08|29|52|56
06|18|23|35|38|60|71|89|95|98
09|27|23|02|95|12|78|41|60|77
04|17|20|38|42|56|61|79|83|95
67|42|02|56|77|98|24|52|86|61
11|01|18|22|34|42|56|66|75|92
69|69|69|69|69|69|69|69|69|69
82|52|08|18|11|67|84|66|70|80
11|69|38|23|28|62|66|08|77|21
01|01|01|01|01|01|01|01|01|01
08|11|12|20|21|55|69|70|80|96
16|16|16|16|16|16|16|16|16|16
16|16|16|16|16|16|16|16|16|16
17|21|32|39|48|63|70|79|55|84
32|21|48|15|99|22|83|35|97|25
11|16|18|30|34|93|94|71|70|69
01|04|09|17|27|36|43|81|83|97
49|56|20|52|62|63|74|70|40|66
11|96|32|22|21|84|35|06|62|18
09|98|11|35|85|29|75|52|32|30
25|28|35|60|61|11|11|12|16|78
02|08|15|22|29|42|55|69|82|89

[JoséQuintas]

Em Clipper mesmo?

Se os números sempre estão com dois caracteres, um FOR/NEXT poderia ser usado.

Código: Selecionar todos

FOR nCont = 1 TO Len( cText ) STEP 3
   nNumero := Val( Substr( cText, nCont, 2 ) )
NEXT

Talvez um array pra armazenar os números e a quantidade de cada um, se a quantidade for importante.

Código: Selecionar todos

aList := {}
...
nPos := ASCan( aList, { | e | e[ 1 ] == nNumero } ) // a confirmar se no ASCan() do Clipper o parâmetro do codeblock é o primeiro
IF nPos == 0
  AAdd( aList, { nNumero, 1 } )
ELSE
   aList[ nPos, 2 ] += 1
ENDIF

Depois seria listar as quantidades maiores que 1

Código: Selecionar todos

FOR nCont = 1 TO Len( aList )
   IF aList[ nCont, 2 ] > 1
      ? "numero:", aList[ nCont, 1 ], "qtde:", aList[ nCont, 2 ]
   ENDIF
NEXT

Seria por aí, depende exatamente de como precisa do resultado.

Se fosse Harbour, poderia usar o hb_RegExSplit() pra separar os números mais rápido, e também o FOR/EACH, ou talvez AEval().

[ANDRIL]

Veja se é isso que procura, creio que deva compilar normalmente em Clipper.

Código: Selecionar todos

txt = "04|09|16|23|39|43|80|85|94|99|30|30|30|30|30|01|01|01|01|01|04|04|16|23|39|43|80|85|94"
aNum = Split(txt)
aSort(aNum)

maximo=len(aNum)
aSaida:={}
for i=1 to maximo
	pos=ascan(aSaida,{|e| e[1]=aNum[i]})
	if pos=0
	aadd(aSaida,{aNum[i],1})
	else
	aSaida[pos][2]+=1
	endif
next

for i=1 to len(aSaida)
	? aSaida[i][1], aSaida[i][2]
next
wait"veja o resultado"

*******************
Function Split(txt)
*******************
//txt = "04|09|16|23|39|43|80|85|94|99|30|30|30|30|30|01|01|01|01|01|04|04|16|23|39|43|80|85|94"
txt = iif(!"|"$txt,txt+"|",txt)
aNum:={}
do while len(txt)>0 
	pos=AT("|",txt)
	if pos>0
		num=substr(txt,1,AT("|",txt)-1)
	else
		num=txt
		txt=""
	endif
	aadd(aNum,num)

	if !"|"$txt
	exit
	endif

	pos=AT("|",txt)
	txt=substr(txt,AT("|",txt)+1)
enddo
return aNum

[informais]

Olá amigo ANDRIL

A principio exatamente o que quero, agora é Adptar a minha realidade

[JoséQuintas]

A função Split ficou meio confusa.
Talvez melhor assim:

Código: Selecionar todos

FUNCTION Split( cTxt )

LOCAL aList := {}

cTxt := Trim( cTxt )
IF Right( cTxt, 1 ) != "|" .AND. Len( cTxt ) > 1
  cTxt += "|"
ENDIF
DO WHILE "|" $ cTxt
   nPos := At( "|", cTxt )
   cNum := Substr( cTxt, 1, nPos - 1 )
   cTxt  := Substr( cTxt, nPos + 1 )
   AAdd( aList, cNum )
ENDDO

RETURN aList

[alxsts]

Olá!

Segue a minha versão da rotina:

Código: Selecionar todos

// Preciso ler uma (string/Texto) que na verdade está armazenando dezenas, 
// e que está separada por PIPE
// Preciso saber quantas vezes e quais números repetem nela, separados por PIPE |
#include "setcurs.ch"

PROCEDURE Duplicados()
   // Alexandre Santos - Fórum PC Toledo
   LOCAL cDup, cString, nLimit, nOuter, cSearch
   LOCAL nCount, nInner, nOffSet, cOldColor, nOldCursor

   RELEASE GetList
   REQUEST DBFCDX
   RDDSETDEFAULT( "DBFCDX" )

   cOldColor  := SetColor( "W+/B,B/W" ) ; CLS
   nOldCursor := SC_NONE

   If ! File( "DEZENAS.DBF" )
      DbCreate("Dezenas", { { "Dezenas", "C", 29, 0 }, { "Duplicados", "C", 80, 0 } }, "DBFCDX" )

      DBUSEAREA( .T., "DBFCDX", "DEZENAS", "DEZENAS", .F. )

      DbAppend() ;  DEZENAS->dezenas := "17|20|22|27|30|35|41|42|75|95"
      DbAppend() ;  DEZENAS->dezenas := "71|16|25|34|70|27|80|43|61|06"
      DbAppend() ;  DEZENAS->dezenas := "04|12|17|29|39|43|48|67|69|81"
      DbAppend() ;  DEZENAS->dezenas := "95|94|98|97|08|77|83|84|85|20"
      DbAppend() ;  DEZENAS->dezenas := "01|01|01|01|01|01|01|01|01|01"
      DbAppend() ;  DEZENAS->dezenas := "04|06|08|12|17|28|29|39|79|86"
      DbAppend() ;  DEZENAS->dezenas := "11|18|23|27|39|43|49|74|77|84"
      DbAppend() ;  DEZENAS->dezenas := "27|95|06|35|61|56|98|49|17|01"
      DbAppend() ;  DEZENAS->dezenas := "43|16|74|56|84|08|34|55|69|06"
      DbAppend() ;  DEZENAS->dezenas := "01|06|09|16|35|49|62|70|89|99"
      DbAppend() ;  DEZENAS->dezenas := "18|17|38|98|06|02|43|22|49|27"
      DbAppend() ;  DEZENAS->dezenas := "27|06|32|35|75|81|08|29|52|56"
      DbAppend() ;  DEZENAS->dezenas := "06|18|23|35|38|60|71|89|95|98"
      DbAppend() ;  DEZENAS->dezenas := "09|27|23|02|95|12|78|41|60|77"
      DbAppend() ;  DEZENAS->dezenas := "04|17|20|38|42|56|61|79|83|95"
      DbAppend() ;  DEZENAS->dezenas := "67|42|02|56|77|98|24|52|86|61"
      DbAppend() ;  DEZENAS->dezenas := "11|01|18|22|34|42|56|66|75|92"
      DbAppend() ;  DEZENAS->dezenas := "69|69|69|69|69|69|69|69|69|69"
      DbAppend() ;  DEZENAS->dezenas := "82|52|08|18|11|67|84|66|70|80"
      DbAppend() ;  DEZENAS->dezenas := "11|69|38|23|28|62|66|08|77|21"
      DbAppend() ;  DEZENAS->dezenas := "01|01|01|01|01|01|01|01|01|01"
      DbAppend() ;  DEZENAS->dezenas := "08|11|12|20|21|55|69|70|80|96"
      DbAppend() ;  DEZENAS->dezenas := "16|16|16|16|16|16|16|16|16|16"
      DbAppend() ;  DEZENAS->dezenas := "16|16|16|16|16|16|16|16|16|16"
      DbAppend() ;  DEZENAS->dezenas := "17|21|32|39|48|63|70|79|55|84"
      DbAppend() ;  DEZENAS->dezenas := "32|21|48|15|99|22|83|35|97|25"
      DbAppend() ;  DEZENAS->dezenas := "11|16|18|30|34|93|94|71|70|69"
      DbAppend() ;  DEZENAS->dezenas := "01|04|09|17|27|36|43|81|83|97"
      DbAppend() ;  DEZENAS->dezenas := "49|56|20|52|62|63|74|70|40|66"
      DbAppend() ;  DEZENAS->dezenas := "11|96|32|22|21|84|35|06|62|18"
      DbAppend() ;  DEZENAS->dezenas := "09|98|11|35|85|29|75|52|32|30"
      DbAppend() ;  DEZENAS->dezenas := "25|28|35|60|61|11|11|12|16|78"
      DbAppend() ;  DEZENAS->dezenas := "02|08|15|22|29|42|55|69|82|89"
      DbAppend() ;  DEZENAS->dezenas := "55|08|15|02|29|08|55|15|42|08"
                                     //  0...x....1....x....2....x...2
                                     //  12345678901234567890123456789
   Else      
      DBUSEAREA( .T., "DBFCDX", "DEZENAS", "DEZENAS", .F. )
   Endif

   DEZENAS->( DbGoTop() )

   nOffSet := 3

   // percorre os registros
   While ! DEZENAS->( Eof() )
      cDup    := ""
      cString := DEZENAS->dezenas
      nLimit  := Len( cString )
      nOuter  := 1

      // loop externo... percorre as dezenas de cada registro
      While nOuter < nLimit
         cSearch := SubStr( cString, nOuter, 2 )
         nInner := 1
         nCount := 0
         // loop interno... conta cada dezena nas dezenas do registro atual
         While nInner < nLimit
            If Substr( cString, nInner, 2 ) == cSearch
               nCount++
            Endif
            nInner += nOffSet
         Enddo
         // se encontrou mais que um
         If nCount > 1
            // se é a primeira vez que encontrou, guarda
            If At( cSearch + ":", cDup ) == 0
               cDup += If( ! Empty( cDup ), ", ", "" ) + cSearch + ":" + LTrim( Str( nCount ) )
            Endif
         Endif
         nOuter += nOffSet
      Enddo  // nOuter < nLimit
      // se encontrou, grava no próprio registro (arquivo aberto em modo exclusivo)
      If ! Empty( cDup )
         DEZENAS->Duplicados := cDup
      Endif
      // avança registro
      DEZENAS->( DbSkip() )
   Enddo  // ! DEZENAS->( Eof() )

   // exibe registros, fecha arquivo
   DEZENAS->( Browse(), DbCloseArea() )

   // restaura tela
   SetColor( cOldColor ) ; CLS ; SetCursor( nOldCursor )

RETURN
//----------------------------------------------------------------------------------------------------

A função Split ficou meio confusa.

Segue a minha versão:

Código: Selecionar todos

//----------------------------------------------------------------------------------------------------
FUNCTION aTokens( cString, cDelimiter )
   // Alexandre Santos - Fórum PC Toledo
   LOCAL aTokens := {}, nPos, nLen

   If Valtype( cString ) == "C" .And. ( ! Empty( cString := Alltrim( cString ) ) )
      If Valtype( cDelimiter ) == "C" .And. ( ! Empty( cDelimiter ) )
         While ( nPos := At( cDelimiter, cString ) ) > 0
            AAdd( aTokens, SubStr( cString, 1, nPos - 1 ) )
            cString := SubStr( cString, nPos + 1 )
         Enddo
         AAdd( aTokens, cString )
      Else
         // sem delimitador... retorna byte a byte
         nLen := Len( cString )
         For nPos := 1 To nLen
            AAdd( aTokens, SubStr( cString, nPos, 1 ) )
         Next
      Endif
   Endif

RETURN aTokens
//----------------------------------------------------------------------------------------------------

Preciso saber quantas vezes e quais números repetem nela, separados por PIPE |

Não ficou claro se o retorno também é uma string com o resultado separado por pipes. Mas isto é fácil de adaptar...

[informais]

Obrigado a todos,
Fiz um Apanhado das dicas dos amigos e está resolvido