[Ayuda](Batch) 10 Numeros random del 1 al 10

[JoakoDS]

Hola; Soy nuevo en el foro, y me uní para hacer una consulta.

Resulta que estoy en un proyecto donde estoy estudiando, y estamos haciendo un programita en bat, el programa consta de Preguntas, que el usuario(jugador) deberá responder, parte de la consigna menciona que las preguntas deberan realizarse con un orden aleatorio cada vez que se juegue una partida, por lo tanto, no pueden salir 2       veces en el mismo orden, algo asi  Partida1) ={10  6  5  4   3  1  2  9  7  8} Partida2) ={1  3  10  5  7  4  6  2  9  8}. Cada numero vendria a ser una pregunta distinta.

El problema es que no consigo encontrar la manera de generar un batch que genere cada vez que se inicia, 10 numeros distintos en un rango de 0-9.

Espero que me puedan ayudar, gracias.

[Eleкtro]

¿Tiene que ser puro Batch, o se permite la utilización de un script-Batch hibrido que genere un código VBS?

Sincéramente, en mi opinión, deberías ir al profesor y decirle que has preferido evitar el uso de una herramienta simplista como Batch para generar la lógica del algoritmo de aletoriedad, ya que Batch es ineficiente y carece de lógica en ese aspecto, y aparte de quedar como un "Pro", estarías haciendo lo mejor, aunque yo directamente te diría que lo hicieras en Python, Ruby, u otros xD pero entiendo que eso ya es pedir demasiado (porque la clase es de Batch).

Digo esto porque la lógica aleatoria de Batch no permite seleccionar una serie de números distintos dentro de un rango, y que el número elegido sea distinto cada vez, mucho menos permite la utilización de Arrays, así que lo más propable es que el mismo numero aleatorio se repita varias veces y debas corregirlo, es decir, seguir obteniendo otro dígito aleatorio hasta que sea distinto al dígito anterior, y esto, medido en tiempo de ejecución puede tardar bastante para conseguir un 0, y luego un 1, dígitos distintos y que no se repitan entre si.

No merece la pena realizar esa cutrez en Batch, pero si quieres hacerlo, puedes utilizar la variable dinámica %Random%, y hacerle un Substring al String resultante para quedarte con un valor que tenga una longitud de un dígito, y luego hacer las comparaciones necesarias (¿es un 0?, ¿es un 1?, etc),
también se podría hacer de otra forma relacionada, que sería simulando un Array como parámetro de un For ("1 2 3 4 5 6 7 8 9 0"), o como parámetro de un For /L (0, 1, 9), y desordenar las posiciones de los elementos recurriendo a los resultados de la variable %Random%, sea como sea cualquiera de esas técnicas es una completa cutrez.

Te muestro un ejemplo en VBS (el cual puedes llamar/usar desde Batch), VBS tampoco ofrece demasiada libertad, no es un lenguaje muy potente ni muy eficiente pero sin duda es mucho más liviano de lo que sería en Batch.

Código (vb) [Seleccionar] Expandir

Randomize

' El máximo número de combinaciones posibles con un rango de '0-9' y sin repetición son '3.628.800',
' Fuente: www.mathsisfun.com/combinatorics/combinations-permutations-calculator.html
'
' Pero ese colosal valor disminuiría el rendimiento del código,
' y no creo que un jugador pueda llegar a hacer más de '1.000' partidas por sesión.
Dim Combos(1000)

' Un Array con los valores que permutar.
Values = Array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

' Gerero y asigno la primera combinación aleatoria.
Combos(0) = RandomizeArray(Values)

' Genero el resto de combos.
DoCombos()
' Escribir los combos en un archivo de texto
' O enviarlos a la salida de la consola para procesarlos con un For en Batch.
' Como se prefiera.
WScript.Echo("Fin")

Sub DoCombos()

' Recorro los espacios vaciós del Array para llenarlos.
For X = 0 To (UBound(Combos) - 1)

IsRepeated = False

   ' Gerero la siguiente combinación aleatoria.
   Combo = RandomizeArray(Values)

   ' Compruebo que la combinación no existe en el Array de combos.
   For Y = 0 To (X)

    On Error Resume Next

       If Join(Combos(Y), "") = Join(Combo, "") Then
          IsRepeated = True
          Exit For
       End If

   Next

   ' Añado la combinación al Araay de combinaciones.
   If Not IsRepeated Then
      Combos(X + 1) = Combo
   End If
   
Next

End Sub

' Función que desordena los elementos de un array.
Function RandomizeArray(arr)

   tmpArray   = arr
   firstIndex = LBound(tmpArray)
   itemCount  = (UBound(tmpArray) - LBound(tmpArray)) + 1
   
   For index = UBound(tmpArray) To (LBound(tmpArray) + 1) Step -1
       
       ' evaluate a random index from LBound to INDEX
       newIndex = (firstIndex + Int(Rnd * itemCount))
       
       ' swap the two items
       tmpValue           = tmpArray(index)
       tmpArray(index)    = tmpArray(newIndex)
       tmpArray(newIndex) = tmpValue
       
       ' prepare for next iteration
       itemCount = itemCount - 1
 
   Next

   RandomizeArray = tmpArray

End Function

[JoakoDS]

La verdad que me sorprendio la rapidez con la que recibi una respuesta, el sabado voy a preguntarle sobre el uso de VBS, y tambien de NirSoft que lo inclui por una funcion mas.
De todas maneras Eleкtro, aunque logre entender la gran mayoria del codigo, no termino de entender como pasar los 'combos' a un archivo de texto, o mostrarlos en la pantalla; desconozco el tema de los VBS, ahora mismo pienso leer rapidamente el tutorial que esta rondando por acá.
En el caso de que el profesor no lo permita, encontre una manera de que a simple vista no se repitan las preguntas pero no seria completamente aleatorio, no me quiero extender mucho. De todas maneras, quiero adentrarme en los VBS, nunca esta de mas aprender, gracias por la respuesta.

[Eleкtro]

La cosa es así, Batch es tan... tan... ¡manco! que un programador deberá recurrir a la utilización de otros lenguajes (porque Batch, cuesta calificarlo como "Lenguaje") para llevar a cabo ciertas tareas, o bien porque Batch no ofrece los medios, o bien porque en otro lenguaje va a resultar más cómodo el desarrollo y el rendimiento resultante será mucho mejor ...que sin duda, lo es.  

De todas maneras Eleкtro, aunque logre entender la gran mayoria del codigo, no termino de entender como pasar los 'combos' a un archivo de texto, o mostrarlos en la pantalla; desconozco el tema de los VBS, ahora mismo pienso leer rapidamente el tutorial que esta rondando por acá.

Añade este método al script de arriba:

Código (vb) [Seleccionar] Expandir

Sub WriteTextFile(ArrayCollection, FilePath, Delimiter)

   Set ObjTxt = CreateObject("Scripting.FileSystemObject"). _
                OpenTextFile(FilePath, 2, True)

   For Each arr In ArrayCollection

       ObjTxt.Writeline(Join(arr, Delimiter))

   Next

  ObjTxt.Close

End Sub

Y luego, antes de finalizar la ejecución del Script, justo después de la instrucción "DoCombos()", añades esto:

Código (vb) [Seleccionar] Expandir

WriteTextFile Combos, ".\Combos.txt", ";"

El resultado será un archivo de texto plano con este contenido:

Código [Seleccionar] Expandir

3;0;5;6;4;9;7;2;8;1
1;7;6;8;5;0;9;2;3;4
3;0;2;4;7;1;8;6;5;9
1;2;5;9;6;8;3;7;4;0
4;2;1;6;5;3;0;8;9;7
0;3;4;6;7;2;8;9;5;1
0;1;4;5;3;9;7;6;2;8
1;3;5;0;2;7;9;4;6;8
4;9;6;0;3;2;7;8;1;5
4;8;6;5;7;9;0;3;1;2
etc...
(No habrá combinaciones repetidas)

PD: El formato del delimitador lo puedes modificar en el parámetro "Delimiter" al llamar al método.



He modificado el método "DoCombos" (ahora lo llamé "FillWithCombos") ya que el control de errores estaba incompleto y provocaba que algunos elementos del Array quedasen vacíos, ya no es necesario un error-handling (otra cosa de la que Batch carece, y VBS en parte también).

Aquí tienes la modificación del código:

Nota: Le añadí el parámetro "AllowDuplicates" al método "FillWithCombos" para hacerlo más liviano, ya que un Array de 100.000 combinacions sin repetición tarda unos pocos segundos en generarse (en Batch eso sería una eternidad, 5-10 min), pero sin repetición tardará muchísimo más ya que tiene que hacer iteraciones al array para comprobar si existe la combinación, esto en un lenguaje como VBS sigue siendo imperfecto, como ya dije tampoco es muy potente, está falto de recursos.
Mi sugerencia, si no te importa que hayan combinaciones duplicadas, puedes hacer las que quieras, será bien rápido, pero si quieres que no hayan duplicados, no sobrepases las 2.000 combinaciones en el Array o irá muy lento.

Código (vb) [Seleccionar] Expandir

' El máximo número de combinaciones posibles con un rango de '0-9' y sin repetición son '3.628.800',
' Fuente: www.mathsisfun.com/combinatorics/combinations-permutations-calculator.html
'
' Pero ese colosal valor disminuiría el rendimiento del código,
' y no creo que un jugador pueda llegar a hacer más de '1.000' partidas por sesión.
Dim Combos(999)

' Un Array con los valores que permutar.
CharSet = Array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

' Llamo al método principal.
Main()

' El método principal.
Sub Main

   On Error Resume Next

   ' Lleno el Array con combos.
   Call FillWithCombos(Combos, CharSet, 0, False)

   ' Escribo las combinaciones generadas del Array, en un archivo de texto.
   Call WriteTextFile(Combos, ".\Combos.txt", ";")

   ' Si hubo algún error...
   If Err.Number <> 0 Then
       ' Envio el código de error a la consola,
       ' el cual puedes procesar checkando la variable dinámica %ERRORLEVEL%.
       WScript.Echo "ExitCode: " & Err.Number & vbNewLine & _
                    "Source: " & Err.Source & vbNewLine & _
                    "Description: " &  Err.Description
       WScript.Quit(Err.Number)

   Else ' Si no hubo ningún error...
       ' Envio un código de salida satisfactorio a la consola,
       ' el cual puedes procesar checkando la variable dinámica %ERRORLEVEL%.
       WScript.Quit(0)

   End If

End Sub

' Función que desordena los elementos de un array.
Randomize
Function RandomizeArray(ByVal arr)

  tmpArray   = arr
  firstIndex = LBound(tmpArray)
  itemCount  = (UBound(tmpArray) - LBound(tmpArray)) + 1

  For index = UBound(tmpArray) To (LBound(tmpArray) + 1) Step -1

      ' evaluate a random index from LBound to INDEX
      newIndex = (firstIndex + Int(Rnd * itemCount))

      ' swap the two items
      tmpValue           = tmpArray(index)
      tmpArray(index)    = tmpArray(newIndex)
      tmpArray(newIndex) = tmpValue

      ' prepare for next iteration
      itemCount = itemCount - 1

  Next

  RandomizeArray = tmpArray

End Function

' Método que rellena un Array con combinaciones elatorias,
' sin repetición de combinaciones.
Sub FillWithCombos(Byref Arr, _
                  Byval Values, _
                  Byval StartIndex, _
                  Byval AllowDuplicates)

   ' Recorro los elementos del Array para llenarlos.
   For X = StartIndex To (UBound(Arr))
 
      ' Un flag Booleano que determina si una combinación está repetida en el Array.
      IsRepeated = False

      ' Gerero la siguiente combinación aleatoria.
      Combo = RandomizeArray(Values)

     
      ' Si no está permitido añadir combinaciones duplicadas...
       If Not AllowDuplicates Then

          ' Si el primer elemento del Array no está vacio...
          If Not IsEmpty(Arr(0)) Then

             ' Determino si ya existe la combinación generada en el Array.
             For Y = 0 To (X - 1)

                 If Join(Arr(Y), "") = Join(Combo, "") Then
                    IsRepeated = True
                    Exit For
                 End If

             Next 'Y

          End If 'IsEmpty(Arr(0))

          ' Si la combinación no está repetida...
          If Not IsRepeated Then
             ' Añado la combinación al Array de combinaciones.
             Arr(X) = Combo

           ' Si la combinación está repetida...
           Elseif IsRepeated Then
             call FillWithCombos(Combos, Values, X, AllowDuplicates)

           End If 'Not IsRepeated

       Else ' Si está permitido añadir combinaciones duplicadas...
           ' Añado la combinación al Array de combinaciones.
           Arr(X) = Combo

       End If ' Not AllowDuplicates

   Next 'X

End Sub

' Método que escribe los Arrays de un Array, en un archivo de texto.
Sub WriteTextFile(ByVal ArrayCollection, _
                 ByVal FilePath, _
                 ByVal Delimiter)

   Set ObjTxt = CreateObject("Scripting.FileSystemObject"). _
                OpenTextFile(FilePath, 2, True)

   For Each arr In ArrayCollection
       ObjTxt.Writeline(Join(arr, Delimiter))
   Next

  ObjTxt.Close

End Sub

Como ya te dije esto lo puedes usar desde Batch, solo tienes que escribir el contenido del script VBS dede tu Batch-Script a un archivo externo, y ejecutarlo.

Código (dos) [Seleccionar] Expandir


@Echo OFF

(

Echo Dim Combos^(999^)
Echo CharSet = Array^(0, 1, 2, 3, 4, 5, 6, 7, 8, 9^)
Echo Main()
Echo Sub Main
Echo     Call FillWithCombos^(Combos, CharSet, 0, False^)
Echo     Call WriteTextFile^(Combos, ".\Combos.txt", ";"^)
Echo     WScript.Quit^(0^)
Echo End Sub
Echo etc...
Echo etc...
Echo etc...

)>"%TEMP%\Script.vbs"

CScript.exe /NoLogo "%TEMP%\Script.vbs"
If %ErrorLevel% EQU 0 (
 Echo Todo OK.
 REM Procesar las combinaciones del archivo de texto resultante...
)

Saludos.

[Eleкtro]

El código anterior de VBS, traducido a Batch podría ser algo como esto:

PD: Pero ya sabes mi opinión, la diferencia de tiempo de ejecución solamente para generar 100-1.000 combinaciones sin repetición en Batch es... ABISMAL (para mal, obvio).

Código [Seleccionar] Expandir

@Echo Off & (CHCP 1252)>Nul & SetLocal EnableDelayedExpansion
Title By .:: Elektro ::.

:: El indicador de máximas combinaciones.
Set /A "MaxCombos=10" - 1

:: El indicador de máxima longitud por combinación.
Set /A "MaxComboLen=10" - 1

:: El valor máximo del rango aleatorio (el valor mínimo es estático, un "0").
Set /A "MaxValue=9" + 1

:: El delimitador de valores.
Set "ValueDelimiter=, "

:: La variable donde cachearé cada combinación por separado.
:: Cada valor estará separado por el delimitador específicado (,).
Set "Combo="

:: El archivo donde guardaré las combinaciones generadas.
:: Nota: En principio iba a usar una variable para simular un Array,
::       Pero luego recordé que la capacidad de Batch está limitado a un Int16 (32.767)
::       Y ese sería el limitado número de caracteres que podría almacenar el "Array".
Set "CombosFile=%Temp%\Combos.txt"

:: El índice inicial de dígito de la combinación,
:: para usarlo en el parámetro del "For Range" (/L)
Set /A "StartIndex=0"



:Main
REM Genero los combos en el archivo de Combos.
Call :DoCombos

REM Ejemplo de como ver el archivo de Combos:
Type "%CombosFile%"
Pause&CLS

REM Ejemplo de como procesar cada valor de cada combo:
For /F "Delims= UseBackQ" %%c IN ("%CombosFile%") Do (

Set "Combo=%%c"
Echo Combinacion: !Combo!
For %%v IN (!Combo!) Do (
Echo Valor: %%v
)
Echo+
)

Pause&Exit /B 0



:DoCombos
REM Elimino posibles restos del archivo de Combos.
REM Creo un nuevo archivo de Combos, vacío.
(
Del /Q "%CombosFile%"
FSUtil.exe File CreateNew "%CombosFile%" 0
)1>Nul 2>&1

REM Genero los Combos hasta llegar a "X" cantidad de Combos.
For /L %%_ In (
0, 1, %MaxCombos%
) Do (
Call :SetCombo
)
Goto:EOF



:SetCombo
For /L %%x In (
!StartIndex!, 1, %MaxComboLen%
) Do (

REM Le añado un dígito aleatorio a la combinación.
REM El valor del rango inicial de la expresión aritmética es "0".
Set /A "Value=!Random! %%!MaxValue!"

REm Compruebo si el dígito existe en la combinación.
(Echo "!Combo!"|Find.exe "%ValueDelimiter%!Value!")1>Nul && (

REM Dígito encontrado.

REM Regreso al método 'SetCombo',
REM Modificando el índice inicial para
REM proseguir el String por el índice del dígito repetido.
Call Set /A "StartIndex=%%x"
Goto :SetCombo

) || (

REM Dígito NO encontrado.

REM Añado el dígito a la combinación.
Set "Combo=!Combo!%ValueDelimiter%!Value!"
REM :: Debug
REM Echo !Combo!

)
)

REM Le hago un arreglo al String para darle el formato correcto.
Set "Combo=!Combo:~2!"
REM :: Debug
REM Echo !Combo!

REm Compruebo si el Combo existe en archivo de Combos.
(Type "!CombosFile!"|Find.exe "!Combo!")1>Nul && (

REM Combo encontrado.

REM Vuelta a empezar, a generar el combo desde Cero.
Call Set /A "StartIndex=0"
Goto :SetCombo

) || (

REM Combo NO encontrado.

REM Añado el combo al archivo de Combos.
(Echo !Combos!%ComboDelimiter%!Combo!)>>"%CombosFile%"
REM :: Debug
REM Echo !Combo!

)

REM Reseteo el valor de las variables.
Set /A "StartIndex=0"
Set /A "Value=0"
Set "Combo="

REM Vuelvo al punto de llamada.
Goto:EOF

Output del archivo de Combos:

Código [Seleccionar] Expandir

2, 9, 6, 0, 3, 7, 8, 1, 4, 5
4, 2, 1, 9, 5, 6, 0, 3, 7, 8
2, 0, 8, 5, 6, 3, 1, 7, 4, 9
3, 8, 1, 5, 6, 9, 4, 2, 0, 7
9, 3, 6, 8, 4, 0, 5, 2, 7, 1
2, 6, 3, 5, 1, 7, 8, 0, 9, 4
8, 4, 2, 9, 5, 1, 6, 3, 7, 0
5, 8, 1, 0, 2, 3, 9, 7, 6, 4
8, 7, 0, 2, 4, 3, 9, 1, 6, 5
7, 8, 3, 1, 0, 6, 5, 2, 4, 9

Output del ejemplo de ayuda (" REM Ejemplo de como procesar cada valor de cada combo"):

Código [Seleccionar] Expandir

Combinacion: 2, 9, 6, 0, 3, 7, 8, 1, 4, 5
Valor: 2
Valor: 9
Valor: 6
Valor: 0
Valor: 3
Valor: 7
Valor: 8
Valor: 1
Valor: 4
Valor: 5

[AquilesBailo]

Yo soy nuevo en esto lo intente pero paso esto.

los números crean un bug en el código y dos números se repiten "aveces" aunque no deberían.

el código:

Código (dos) [Seleccionar] Expandir

@echo off
title bat
:as
cls
set/a asd= 1
set/a asd1= %random:~0,1%
set/a asd2= %random:~0,1%
set/a asd3= %random:~0,1%
set/a asd4= %random:~0,1%
set/a asd5= %random:~0,1%
set/a asd6= %random:~0,1%
set/a asd7= %random:~0,1%
set/a asd8= %random:~0,1%
set/a asd9= %random:~0,1%

if %asd1%==%asd% set/a asd1= %asd1% +1
if %asd2%==%asd% set/a asd2= %asd2% +1
if %asd3%==%asd% set/a asd3= %asd3% +1
if %asd4%==%asd% set/a asd4= %asd4% +1
if %asd5%==%asd% set/a asd5= %asd5% +1
if %asd6%==%asd% set/a asd6= %asd6% +1
if %asd7%==%asd% set/a asd7= %asd7% +1
if %asd8%==%asd% set/a asd8= %asd8% +1
if %asd9%==%asd% set/a asd9= %asd9% +1

if %asd2%==%asd9% set/a asd2= %asd9% +1
if %asd3%==%asd9% set/a asd3= %asd9% +1
if %asd4%==%asd9% set/a asd4= %asd9% +1
if %asd5%==%asd9% set/a asd5= %asd9% +1
if %asd6%==%asd9% set/a asd6= %asd9% +1
if %asd7%==%asd9% set/a asd7= %asd9% +1
if %asd8%==%asd9% set/a asd8= %asd9% +1
if %asd1%==%asd9% set/a asd1= %asd9% +1

if %asd2%==%asd8% set/a asd2= %asd8% +1
if %asd3%==%asd8% set/a asd3= %asd8% +1
if %asd4%==%asd8% set/a asd4= %asd8% +1
if %asd5%==%asd8% set/a asd5= %asd8% +1
if %asd6%==%asd8% set/a asd6= %asd8% +1
if %asd7%==%asd8% set/a asd7= %asd8% +1
if %asd1%==%asd8% set/a asd1= %asd8% +1
if %asd9%==%asd8% set/a asd9= %asd8% +1

if %asd2%==%asd7% set/a asd2= %asd7% +1
if %asd3%==%asd7% set/a asd3= %asd7% +1
if %asd4%==%asd7% set/a asd4= %asd7% +1
if %asd5%==%asd7% set/a asd5= %asd7% +1
if %asd6%==%asd7% set/a asd6= %asd7% +1
if %asd1%==%asd7% set/a asd1= %asd7% +1
if %asd8%==%asd7% set/a asd8= %asd7% +1
if %asd9%==%asd7% set/a asd9= %asd7% +1

if %asd2%==%asd6% set/a asd2= %asd6% +1
if %asd3%==%asd6% set/a asd3= %asd6% +1
if %asd4%==%asd6% set/a asd4= %asd6% +1
if %asd5%==%asd6% set/a asd5= %asd6% +1
if %asd1%==%asd6% set/a asd1= %asd6% +1
if %asd7%==%asd6% set/a asd7= %asd6% +1
if %asd8%==%asd6% set/a asd8= %asd6% +1
if %asd9%==%asd6% set/a asd9= %asd6% +1

if %asd2%==%asd5% set/a asd2= %asd5% +1
if %asd3%==%asd5% set/a asd3= %asd5% +1
if %asd4%==%asd5% set/a asd4= %asd5% +1
if %asd1%==%asd5% set/a asd1= %asd5% +1
if %asd6%==%asd5% set/a asd6= %asd5% +1
if %asd7%==%asd5% set/a asd7= %asd5% +1
if %asd8%==%asd5% set/a asd8= %asd5% +1
if %asd9%==%asd5% set/a asd9= %asd5% +1

if %asd2%==%asd4% set/a asd2= %asd4% +1
if %asd3%==%asd4% set/a asd3= %asd4% +1
if %asd1%==%asd4% set/a asd1= %asd4% +1
if %asd5%==%asd4% set/a asd5= %asd4% +1
if %asd6%==%asd4% set/a asd6= %asd4% +1
if %asd7%==%asd4% set/a asd7= %asd4% +1
if %asd8%==%asd4% set/a asd8= %asd4% +1
if %asd9%==%asd4% set/a asd9= %asd4% +1

if %asd2%==%asd3% set/a asd2= %asd3% +1
if %asd1%==%asd3% set/a asd1= %asd3% +1
if %asd4%==%asd3% set/a asd4= %asd3% +1
if %asd5%==%asd3% set/a asd5= %asd3% +1
if %asd6%==%asd3% set/a asd6= %asd3% +1
if %asd7%==%asd3% set/a asd7= %asd3% +1
if %asd8%==%asd3% set/a asd8= %asd3% +1
if %asd9%==%asd3% set/a asd9= %asd3% +1

if %asd1%==%asd2% set/a asd1= %asd2% +1
if %asd3%==%asd2% set/a asd3= %asd2% +1
if %asd4%==%asd2% set/a asd4= %asd2% +1
if %asd5%==%asd2% set/a asd5= %asd2% +1
if %asd6%==%asd2% set/a asd6= %asd2% +1
if %asd7%==%asd2% set/a asd7= %asd2% +1
if %asd8%==%asd2% set/a asd8= %asd2% +1
if %asd9%==%asd2% set/a asd9= %asd2% +1

if %asd2%==%asd1% set/a asd2= %asd1% +1
if %asd3%==%asd1% set/a asd3= %asd1% +1
if %asd4%==%asd1% set/a asd4= %asd1% +1
if %asd5%==%asd1% set/a asd5= %asd1% +1
if %asd6%==%asd1% set/a asd6= %asd1% +1
if %asd7%==%asd1% set/a asd7= %asd1% +1
if %asd8%==%asd1% set/a asd8= %asd1% +1
if %asd9%==%asd1% set/a asd9= %asd1% +1

echo.
echo %asd% %asd9% %asd2% %asd7% %asd4% %asd6%

%asd3% %asd5% %asd1% %asd8%
echo.
pause

PD: el programa no sirve para nada.

[Eleкtro]

@AquilesBailo

Está prohibido revivir temas antiguos, si tienes una duda, crea un post nuevo.
También debes utilizar las etiquetas GeShi para insertar código.



No entiendo muy bien lo que intentas hacer, pero siguiendo la linea del script del ejemplo que has mostrado, AquilesMuestro un ejemplo de como se podría llevar a cabo la distinción:

Código (dos) [Seleccionar] Expandir

@Echo OFF

:: Inicializo las variables con números aleatorios del 0 al 9.
Set /A "val1=%RANDOM% %%9", "val2=%RANDOM% %%9", "val3=%RANDOM% %%9"
Set /A "val4=%RANDOM% %%9", "val5=%RANDOM% %%9", "val6=%RANDOM% %%9"
Set /A "val7=%RANDOM% %%9", "val8=%RANDOM% %%9", "val9=%RANDOM% %%9"

:: Aumentar el valor del primer parámetro (%val1%)
:: hasta que no coincida con el resto de parámetros (%val2%, %val3%, %val4%, %val5%, %val6%, %val7%, %val8% ,%val9%)
Call :DoWhile "%val1%" "%val2%" "%val3%" "%val4%" "%val5%" "%val6%" "%val7%" "%val8%" "%val9%"
:: Asigno el ""valor de retorno"" del bloque ":DoWhile".
Set /A "val1=%DoWhileResult%"

REM Repetir el mismo proceso de arriba con los demás valores...

Call :DoWhile "%val2%" "%val1%" "%val3%" "%val4%" "%val5%" "%val6%" "%val7%" "%val8%" "%val9%"
Set /A "val2=%DoWhileResult%"

Call :DoWhile "%val3%" "%val1%" "%val2%" "%val4%" "%val5%" "%val6%" "%val7%" "%val8%" "%val9%"
Set /A "val3=%DoWhileResult%"

Call :DoWhile "%val4%" "%val1%" "%val2%" "%val3%" "%val5%" "%val6%" "%val7%" "%val8%" "%val9%"
Set /A "val4=%DoWhileResult%"

Call :DoWhile "%val5%" "%val1%" "%val2%" "%val3%" "%val4%" "%val6%" "%val7%" "%val8%" "%val9%"
Set /A "val5=%DoWhileResult%"

Call :DoWhile "%val6%" "%val1%" "%val2%" "%val3%" "%val4%" "%val5%" "%val7%" "%val8%" "%val9%"
Set /A "val6=%DoWhileResult%"

Call :DoWhile "%val7%" "%val1%" "%val2%" "%val3%" "%val4%" "%val5%" "%val6%" "%val8%" "%val9%"
Set /A "val7=%DoWhileResult%"

Call :DoWhile "%val8%" "%val1%" "%val2%" "%val3%" "%val4%" "%val5%" "%val6%" "%val7%" "%val9%"
Set /A "val8=%DoWhileResult%"

Call :DoWhile "%val9%" "%val1%" "%val2%" "%val3%" "%val4%" "%val5%" "%val6%" "%val7%" "%val8%"
Set /A "val9=%DoWhileResult%"

Echo Valores: %val1%, %val2%, %val3%, %val4%, %val5%, %val6%, %val7%, %val8%, %val9%
Pause&Exit

:DoWhile
Set /A "currentValue=%~1"
If "%currentValue%" EQU "0" (Set /A "currentValue=1")

Set /A "tmpValue=currentValue + 1"
If "%tmpValue%" EQU "10" (Set /A "tmpValue=1")

Set "recall=False"
If "%~1" EQU "%~2" (Set "recall=True")
If "%~1" EQU "%~3" (Set "recall=True")
If "%~1" EQU "%~4" (Set "recall=True")
If "%~1" EQU "%~5" (Set "recall=True")
If "%~1" EQU "%~6" (Set "recall=True")
If "%~1" EQU "%~7" (Set "recall=True")
If "%~1" EQU "%~8" (Set "recall=True")
If "%~1" EQU "%~9" (Set "recall=True")

If /I "%recall%" EQU "True" (
Call :DoWhile "%tmpValue%" "%~2" "%~3" "%~4" "%~5" "%~6" "%~7" "%~8" "%~9"
) ELSE (
Set /A "DoWhileResult=%currentValue%"
Goto :EOF
)

Output:

Código [Seleccionar] Expandir

Valores: 2, 9, 5, 8, 6, 7, 1, 4, 3
Presione una tecla para continuar . . .

Tema Cerrado.

Saludos