c# - una - programa que imprima los numeros del 1 al 1000 en c++

Cómo imprimir 1 a 100 sin ningún bucle usando C#

Question

Estoy intentando imprimir números del 1 al 100 sin usar bucles, usando C #. ¿Alguna pista?

Answer 1

Con expresiones regulares

using System.Text.RegularExpressions;
public class Hello1
{
public static void Main()
{
// Count to 128 in unary
string numbers = "x/n";
numbers += Regex.Replace(numbers, "x+/n", "x$&");
numbers += Regex.Replace(numbers, "x+/n", "xx$&");
numbers += Regex.Replace(numbers, "x+/n", "xxxx$&");
numbers += Regex.Replace(numbers, "x+/n", "xxxxxxxx$&");
numbers += Regex.Replace(numbers, "x+/n", "xxxxxxxxxxxxxxxx$&");
numbers += Regex.Replace(numbers, "x+/n", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx$&");
numbers += Regex.Replace(numbers, "x+/n", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx$&");
// Out of 1..128, select 1..100
numbers = Regex.Match(numbers, "(.*/n){100}").Value;
// Convert from unary to decimal
numbers = Regex.Replace(numbers, "x{10}", "<10>");
numbers = Regex.Replace(numbers, "x{9}", "<9>");
numbers = Regex.Replace(numbers, "x{8}", "<8>");
numbers = Regex.Replace(numbers, "x{7}", "<7>");
numbers = Regex.Replace(numbers, "x{6}", "<6>");
numbers = Regex.Replace(numbers, "x{5}", "<5>");
numbers = Regex.Replace(numbers, "x{4}", "<4>");
numbers = Regex.Replace(numbers, "x{3}", "<3>");
numbers = Regex.Replace(numbers, "x{2}", "<2>");
numbers = Regex.Replace(numbers, "x{1}", "<1>");
numbers = Regex.Replace(numbers, "(<10>){10}", "<100>");
numbers = Regex.Replace(numbers, "(<10>){9}", "<90>");
numbers = Regex.Replace(numbers, "(<10>){8}", "<80>");
numbers = Regex.Replace(numbers, "(<10>){7}", "<70>");
numbers = Regex.Replace(numbers, "(<10>){6}", "<60>");
numbers = Regex.Replace(numbers, "(<10>){5}", "<50>");
numbers = Regex.Replace(numbers, "(<10>){4}", "<40>");
numbers = Regex.Replace(numbers, "(<10>){3}", "<30>");
numbers = Regex.Replace(numbers, "(<10>){2}", "<20>");
numbers = Regex.Replace(numbers, "(<[0-9]{3}>)$", "$1<00>");
numbers = Regex.Replace(numbers, "(<[0-9]{2}>)$", "$1<0>");
numbers = Regex.Replace(numbers, "<([0-9]0)>/n", "$1/n");
numbers = Regex.Replace(numbers, "<([0-9])0*>", "$1");
System.Console.WriteLine(numbers);
}
}

La salida:

# => 1
# => 2
# ...
# => 99
# => 100

Answer 2

Esto es más o menos un pseudocódigo que no he hecho c # en años, el PS se ejecuta con 1 hora de sueño, así que podría estar equivocado.

int i = 0;
public void printNum(j){
if(j > 100){
break;
} else {
print(j);
printNum(j + 1);
}
}
public void main(){
print(i);
printNum(i + 1);
}

Answer 3

La manera genial y divertida:

static void F(int[] array, int n)
{
Console.WriteLine(array[n] = n);
F(array, n + 1);
}
static void Main(string[] args)
{
try { F(new int[101], 1); }
catch (Exception e) { }
}

Answer 4

Método A:

Console.WriteLine(''1'');
Console.WriteLine(''print 2'');
Console.WriteLine(''print 3'');
...
Console.WriteLine(''print 100'');

Método B:

func x (int j)
{
Console.WriteLine(j);
if (j < 100)
x (j+1);
}
x(1);

Answer 5

Mi solución está en el hilo 2045637 , que hace la misma pregunta para Java.

Answer 6

Para cuando conteste esto, alguien ya lo tendrá, así que aquí está de todos modos, con crédito para Caleb:

void Main()
{
print(0, 100);
}
public void print(int x, int limit)
{
Console.WriteLine(++x);
if(x != limit)
print(x, limit);
}

Answer 7

Puedo pensar de dos maneras. ¡Uno de ellos implica alrededor de 100 líneas de código!

Hay otra forma de reutilizar un poco de código varias veces sin usar un ciclo while / for ...

Sugerencia: realice una función que imprima los números de 1 a N. Debería ser fácil hacerlo funcionar para N = 1. Luego, piense en cómo hacer que funcione para N = 2.

Answer 8

Puedo pensar de dos maneras:

• utilizando 100 Console.WriteLine
• usando goto en una declaración de switch

Answer 9

Recursion tal vez?

public static void PrintNext(i) {
if (i <= 100) {
Console.Write(i + " ");
PrintNext(i + 1);
}
}
public static void Main() {
PrintNext(1);
}

Answer 10

Sin bucles, sin condicionales y sin salida literal codificada, también conocida como solución "divide y vencerás FTW":

class P
{
static int n;
static void P1() { System.Console.WriteLine(++n); }
static void P2() { P1(); P1(); }
static void P4() { P2(); P2(); }
static void P8() { P4(); P4(); }
static void P16() { P8(); P8(); }
static void P32() { P16(); P16(); }
static void P64() { P32(); P32(); }
static void Main() { P64(); P32(); P4(); }
}

Enfoque alternativo:

using System;
class C
{
static int n;
static void P() { Console.WriteLine(++n); }
static void X2(Action a) { a(); a(); }
static void X5(Action a) { X2(a); X2(a); a(); }
static void Main() { X2(() => X5(() => X2(() => X5(P)))); }
}

Answer 11

Sin bucles, sin recurrencia, solo una serie de funciones similar a una tabla de acceso para elegir cómo realizar la bifurcación:

using System;
using System.Collections.Generic;
namespace Juliet
{
class PrintStateMachine
{
int state;
int max;
Action<Action>[] actions;
public PrintStateMachine(int max)
{
this.state = 0;
this.max = max;
this.actions = new Action<Action>[] { IncrPrint, Stop };
}
void IncrPrint(Action next)
{
Console.WriteLine(++state);
next();
}
void Stop(Action next) { }
public void Start()
{
Action<Action> action = actions[Math.Sign(state - max) + 1];
action(Start);
}
}
class Program
{
static void Main(string[] args)
{
PrintStateMachine printer = new PrintStateMachine(100);
printer.Start();
Console.ReadLine();
}
}
}

Answer 12

Solo LINQ ...

Console.WriteLine(Enumerable.Range(1, 100)
.Select(s => s.ToString())
.Aggregate((x, y) => x + "," + y));

Answer 13

Solo por la fea interpretación literal:

Console.WriteLine("numbers from 1 to 100 without using loops, ");

(Puedes reír ahora o más tarde, o no)

Answer 14

Un método completamente innecesario:

int i = 1;
System.Timers.Timer t = new System.Timers.Timer(1);
t.Elapsed += new ElapsedEventHandler(
(sender, e) => { if (i > 100) t.Enabled = false; else Console.WriteLine(i++); });
t.Enabled = true;
Thread.Sleep(110);

Answer 15

Uno mas:

Console.WriteLine(
String.Join(
", ",
Array.ConvertAll<int, string>(
Enumerable.Range(1, 100).ToArray(),
i => i.ToString()
)
)
);

Answer 16

Console.Out.WriteLine(''1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100'');

Answer 17

Console.WriteLine(''1'');
Console.WriteLine(''2'');
...
Console.WriteLine(''100'');

... ¿O hubieras aceptado una solución recursiva?

EDITAR: o puede hacer esto y usar una variable:

int x = 1;
Console.WriteLine(x);
x+=1;
Console.WriteLine(''2'');
x+=1;
...
x+=1
Console.WriteLine(''100'');

Answer 18

Enumerable.Range(1, 100)
.Select(i => i.ToString())
.ToList()
.ForEach(s => Console.WriteLine(s));

No estoy seguro de si esto cuenta ya que el ciclo está algo oculto, pero si es legítimo es una solución idiomática al problema. De lo contrario, puedes hacer esto.

 int count = 1;
top:
if (count > 100) { goto bottom; }
Console.WriteLine(count++);
goto top;
bottom:

Por supuesto, esto es efectivamente lo que se traducirá a un bucle de todos modos, pero ciertamente está mal visto en estos días para escribir código como este.

Answer 19

Enumerable.Range(1, 100).ToList().ForEach(i => Console.WriteLine(i));

Aquí hay un desglose de lo que está sucediendo en el código anterior:

• Enumerable.Range devuelve el rango especificado de números enteros como IEnumerator <Int32>
• Enumerable.ToList<T> convierte un IEnumerable <T> en una lista <T>
• List<T>.ForEach toma una función lamdba y la invoca para cada elemento de la lista

Consideración de rendimiento

La llamada a la lista hará que se asigne la memoria para todos los elementos (en el ejemplo anterior 100 entradas). Esto significa O (N) complejidad del espacio. Si esto es una preocupación en su aplicación, es decir, si el rango de los enteros puede ser muy alto, entonces debe evitar ToList y enumerar los elementos directamente.

Desafortunadamente, ForEach no forma parte de las extensiones de IEnumerable que se proporcionan de fábrica (de ahí la necesidad de convertir a List en el ejemplo anterior). Afortunadamente, esto es bastante fácil de crear:

static class EnumerableExtensions
{
public static void ForEach<T>(this IEnumerable<T> items, Action<T> func)
{
foreach (T item in items)
{
func(item);
}
}
}

Con la extensión anterior de IEnumerable, ahora en todos los lugares donde necesita aplicar una acción a un IEnumerable, simplemente puede llamar a ForEach con un lambda. Así que ahora el ejemplo original se ve así:

Enumerable.Range(1, 100).ForEach(i => Console.WriteLine(i));

La única diferencia es que ya no llamamos a ToList, y esto da como resultado un uso de espacio constante (O (1)) ... lo cual sería una ganancia bastante notable si estuvieras procesando una gran cantidad de elementos.

Answer 20

PrintNum(1);
private void PrintNum(int i)
{
Console.WriteLine("{0}", i);
if(i < 100)
{
PrintNum(i+1);
}
}

Answer 21

class Program
{
static Timer s = new Timer();
static int i = 0;
static void Main(string[] args)
{
s.Elapsed += Restart;
s.Start();
Console.ReadLine();
}
static void Restart(object sender, ElapsedEventArgs e)
{
s.Dispose();
if (i < 100)
{
Console.WriteLine(++i);
s = new Timer(1);
s.Elapsed += Restart;
s.Start();
}
}
}

Debes notar que NO estoy usando recursividad.

Answer 22

class Program
{
static int temp = 0;
public static int a()
{
temp = temp + 1;
if (temp == 100)
{
Console.WriteLine(temp);
return 0;
}
else
Console.WriteLine(temp);
Program.a();
return 0;
}
public static void Main()
{
Program.a();
Console.ReadLine();
}
}

Answer 23

namespace ConsoleApplication2 {
class Program {
static void Main(string[] args) {
Print(Enumerable.Range(1, 100).ToList(), 0);
Console.ReadKey();
}
public static void Print(List<int> numbers, int currentPosition) {
Console.WriteLine(numbers[currentPosition]);
if (currentPosition < numbers.Count - 1) {
Print(numbers, currentPosition + 1);
}
}
}
}

Answer 24

public void Main()
{
printNumber(1);
}
private void printNumber(int x)
{
Console.WriteLine(x.ToString());
if(x<101)
{
x+=1;
printNumber(x);
}
}

Answer 25

using static IronRuby.Ruby;
class Print1To100WithoutLoopsDemo
{
static void Main() =>
CreateEngine().Execute("(1..100).each {|i| System::Console.write_line i }");
}

Oye, ¿por qué no?