java - suma - Mostrar números del 1 al 100 sin bucles o condiciones

sumar los numeros enteros de 1 a 100 mediante estructura repetir java

Question

¿Hay alguna manera de imprimir números del 1 al 100 sin usar ningún bucle o condiciones como "si"? Podemos hacer fácilmente el uso de la recursión, pero eso nuevamente tiene una condición if. ¿Hay una manera de hacerlo sin usar "si" también? También no hay declaraciones de impresión repetitiva, o una sola declaración de impresión que contiene todos los números del 1 al 100.

Una solución en Java es preferible.

Answer 1

¿Hay alguna manera de imprimir números del 1 al 100 sin usar ningún bucle o condiciones como "si"?

No puedo creer que nadie haya sugerido esto todavía:

System.out.println("numbers from 1 to 100 without using any loops or conditions like /"if/"?");

Answer 2

¿Hay alguna manera de imprimir números del 1 al 100 sin usar ningún bucle o condiciones como "si"?

Usando una versión optimizada de this :

System.out.println("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");

¿Próxima pregunta?

Answer 3

¿Tiene que ser Java? Si ruby ​​está permitido:

puts [*1..100].join("/n")

Me gustaría ver algo tan conciso en Java.

Answer 4

Abusar de una excepción para que sirva como condición.

public class Main {
private static int[] stopper = new int[100];
public static void main(String[] args) {
try {
print(1);
} catch(ArrayIndexOutOfBoundsException e) {
// abuse of try catch
}
}
private static void print(int i) {
System.out.println(i);
stopper[i] = i;
print(i + 1);
}
}

Answer 5

Aquí hay una pista que puede ser útil.

La declaración assert no es la declaración prohibida if .

Answer 6

Aquí hay uno que usa un hilo (inflé el tiempo de reposo para dar cuenta de las fluctuaciones en la velocidad del sistema). No se me ocurrió una forma de deshacerme del try / catch:

public class Counter extends Thread{
private int cnt;
public Counter(){
this.cnt = 0;
}
private void increment(){
System.out.println(cnt++);
try{
Thread.sleep(1000);
}catch(Exception e){}
increment();
}
public void run(){
increment();
}
public static void main(String[] args) throws Exception{
Counter cntr = new Counter();
cntr.start();
cntr.join(100000);
cntr.interrupt();
System.exit(0);
}
}

Answer 7

Basándose en la respuesta de Yacoby, pero sin la trampa. (Vota la respuesta).

public class To100 {
public static void main(String[] args) {
final int max = 100;
new java.util.concurrent.Semaphore(max) {
void go() {
acquireUninterruptibly();
System.err.println(max-availablePermits());
go();
}
}.go();
}
}

Explicación:

• Semaphore permite que se adquiera un número específico de permisos antes del bloqueo.
• No quería escribir java.util.concurrent dos veces, por lo que extendí de forma oportunista a Semaphore .
• Esto usa una clase interna anónima. Anónimo no significa que no sea un tipo. Por lo tanto, puedo llamar a un método que no está declarado en un tipo de base / interfaz implementada.
• acquireUninterruptibly significa que no tengo que declarar excepciones controladas molestas.
• Nadie dijo que el programa debía terminar.

Answer 8

Conoce tus bibliotecas.

public class To100 {
public static void main(String[] args) {
String set = new java.util.BitSet() {{ set(1, 100+1); }}.toString();
System.out.append(set, 1, set.length()-1);
}
}

(Puede usar String.replaceAll para cambiar el separador. Por ejemplo, .replaceAll(", ", " ") para separar el espacio).

Explicación:

• java.util.BitSet es una pequeña clase útil que representa un conjunto arbitrariamente grande (no escaso) de enteros positivos. (Tiene tan malas partes: no es definitivo, es innecesariamente seguro para subprocesos, no es compatible con la construcción, etc.) ta.
• Extiende BitSet me permite escribir java.util solo una vez. El "operador de diamantes" JDK7 debería ayudar a reducir la duplicación con tipos genéricos, pero no ayuda para la situación más común. :(
• Las llaves dobles son la expresión idiomática Double Brace , una clase interna anónima que contiene solo un inicializador de instancia. Es un truco. Aumenta el tamaño del tiempo de ejecución y, por lo tanto, el tiempo de inicio. El tamaño de la distribución es insignificante si usa pack200.gz. Creo que el mundo moderno está listo para eso. Tus colegas pueden no estarlo. Tal vez comience usándolo para la prueba da
• BitSet.set establece un bit en el conjunto (dos significados completamente diferentes de la palabra "establecer" allí - me gusta). Es un rango medio abierto, el valor superior exclusivo; el fondo inclusive. Agregue 1 a la cima para incluir 100.
• BitSet.toString está realmente definido con precisión por los documentos API.
• append se agregó a PrintStream con la introducción de la interfaz Appendable en J2SE 5.0. Básicamente, hace una subcadena e imprime el resultado. (Un pequeño secreto: esto no está garantizado por la especificación para purgar la salida, pero las implementaciones siempre lo harán).
• Al iniciar el apéndice en 1, y al quitar uno, se BitSet los tirantes de la representación de cadena de BitSet .
• "Conoce tus bibliotecas". Tomado de Josh Bloch. Ver Puzzles de Java, rompecabezas 94. Realmente es bueno saber qué hay en las bibliotecas. Al menos saber dónde buscar. Ahorre tiempo, ahorre tiempo de mantenimiento y hágalo bien la primera vez.

Answer 9

Consulte la respuesta Divide + Conquer de la cadena C #. Es malo, pero brillante:

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

Aquí está la versión de Java:

public class Application {
public static void main(String[] args) {
Print64Numbers();
Print32Numbers();
Print4Numbers();
}
private static int currentNumber = 0;
private static void Print1Number() { System.out.println(++currentNumber); }
private static void Print2Numbers() { Print1Number(); Print1Number(); }
private static void Print4Numbers() { Print2Numbers(); Print2Numbers(); }
private static void Print8Numbers() { Print4Numbers(); Print4Numbers(); }
private static void Print16Numbers() { Print8Numbers(); Print8Numbers(); }
private static void Print32Numbers() { Print16Numbers(); Print16Numbers(); }
private static void Print64Numbers() { Print32Numbers(); Print32Numbers(); }
}

Answer 10

En C ++:

#include <iostream>
class a {
static unsigned i;
public:
a() {
std::cout << ++i << std::endl;
}
};
unsigned a::i = 0U;
int main() {
a array[100];
}

Esta solución no usa bucles ni recursión para imprimir números del 1 al 100.

Answer 11

Esta respuesta es lo suficientemente perversa como para que no parezca que se ejecutará. ;)

Obtiene texto adicional al final de la salida, pero evita bucles, condiciones, main () e println (). ;)

public class OneHundred {
private static int i = 1;
static {
OneHundred[] hundreds = new OneHundred[100];
Arrays.fill(hundreds, new OneHundred(););
Thread.currentThread().setName(Arrays.toString(hundreds).replaceAll("[//]//[, ]+", "/n"));
clear("Exception in thread /""); clear("/" ");
}
private static void clear(String string) {
try {
Field f = String.class.getDeclaredField("count");
f.setAccessible(true);
f.set(string, 0);
} catch (Exception ignored) { }
}
public String toString() { return "" + i++; }
}

Answer 12

Esto me recuerda la programación de mi TI-55 años y años atrás. Tenía 32 pasos de instrucción programables y una instrucción RESET que saltaba a la instrucción cero, por lo que podría implementarse un bucle simple. El problema era hacer que se detuviera, lo que se reducía a que hiciera una operación que causaba un error, por ejemplo, dividir por cero.

Así:

public static void main(String[] args)
{
printN(100);
}
private static void printN(int n)
{
try
{
int t = 1/n; // Exception when n is 0
printN(n-1); // Recurse, down to 0
System.out.println(n);
}
catch (Exception ex)
{
// Stop recursing
}
}

Nota: Sí, sé que esto es similar a la solución de @ Yacoby.

Answer 13

Implemente una llamada recursiva incrementando e imprimiendo el número. Configure su máquina virtual para que se quede sin pila después de 100 llamadas. Sin condiciones, sin bucles. tos ;-)

Answer 14

Mi solución sin verbosidad. No utiliza ninguna estructura de control que no sea la aplicación de función. Tampoco usa el código de la biblioteca para ayudar. Mi código es fácilmente extensible para imprimir el rango [a, b]. Simplemente cambie conts [n / 100] a conts [(n - a) / (b - a)] y por supuesto cambie el new Printable (1) al new Printable (a) .

To100.java:

class Printable {
private static final Continuation[] conts = {new Next (), new Stop ()};
private final int n;
private final Continuation cont;
Printable (int n) {
this.n = n;
this.cont = conts [n / 100];
}
public void print () {
System.out.println (n);
cont.call (n);
}
}
interface Continuation {
public void call (int n);
}
class Next implements Continuation {
public void call (int n) {
new Printable (n + 1).print ();
}
}
class Stop implements Continuation {
public void call (int n) {
// intentionally empty
}
}
class To100 {
public static void main (String[] args) {
new Printable (1).print ();
}
}

EDIT: dado que esta pregunta se cerró (¿por qué?), Publicaré mi segunda respuesta aquí. Está inspirado por el aviso de Tom Hawtin de que el programa no tiene que terminar. Además, la pregunta no requiere que solo se impriman los números del 1 al 100 (o incluso en orden).

To100Again.java:

class To100Again extends Thread {
private static byte n;
public void run () {
System.out.println (n++);
new To100Again ().start ();
System.gc();
}
public static void main (String[] args) {
new To100Again ().start ();
}
}

Answer 15

No vi esto aquí, usando el orden de terminación del operador && .

public class count100 {
public static boolean loop(int i) {
System.out.println(100-i);
return i > 0 && loop(i-1);
}
public static void main(String[] args) {
loop(99);
}
}

Answer 16

O si te gusta usar la reflexión :-)

public class Print100 {
public static void emit0(int index) throws Exception {
System.out.println(index);
String next = new StringBuilder()
.append("emit")
.append(index / 100)
.toString();
Print100.class.getMethod(next, Integer.TYPE)
.invoke(null, index+1);
}
public static void emit1(int index) {
}
public static void main(String[] args) throws Exception {
emit0(1);
}
}

Answer 17

Ok, llegué tarde y ya se aceptó una respuesta, pero me pregunto por qué nadie ha usado un contador limpio y simple todavía.

public class Counter
{
static Counter[] vtab = new Counter[]
{
new Counter(),
new Counter() { public void print( int first, int last ) {} }
};
public void print( int first, int last )
{
vtab[ ( last - first - 1 ) >>> 31 ].print( first, last - 1 );
System.out.println( last );
}
public static void main( String[] args )
{
vtab[ 0 ].print( 1, 100 );
}
}

El hilo es seguro, configurable, sin excepciones, no depende de los efectos secundarios de API, simplemente OOP y algunas matemáticas triviales.

Para quienes no estén familiarizados con los operadores binarios, aquí está cómo funciona:

• La expresión ( x >>> n ) mueve todos los bits del valor entero x a la derecha en n lugares. Los bits más bajos simplemente caen del lado derecho con esta operación y los nuevos que vienen del lado izquierdo siempre son 0 .

• Entonces, el efecto de ( x >>> 31 ) es mover el bit más alto de x al lugar más bajo y establecer todos los demás bits de x en 0 . El resultado ahora es siempre 0 o 1 para todos los valores posibles de x .

• Como el bit más alto de un int es el bit de signo que es 0 para valores positivos y 1 para valores negativos, la expresión ( x >>> 31 ) evalúa a 0 para todos los valores positivos de x a 1 para todos los valores negativos de x .

• Ahora bien, si tanto el first como el last son números positivos y si el last es mayor que el first , el resultado de ( last - first - 1 ) será >= 0 y si el last == first será -1 .

• Entonces ( ( last - first - 1 ) >>> 31 ) evalúa a 0 si el last es mayor que el first y se convierte en 1 si son iguales.

Ahora este valor 0/1 se usa para cambiar entre las 2 implementaciones de print( int first, int last ) basadas en la comparación de first y last . Al principio, la recursión tiene lugar sin imprimir nada. print( 1, 100 ) llama a print( 1, 99 ) y así sucesivamente ... hasta que last first que causa un cambio a la otra implementación de print que a su vez no hace nada en absoluto. Entonces ahora la pila se desenrolla de nuevo y los valores se imprimen en el camino hacia abajo en orden ascendente y la invocación de vtab[ 0 ].print( 1, 100 ) finaliza normalmente.

Answer 18

Otra división y conquista:

public class Print100 {
public static void main (String...args) {
Runnable r1 = new Runnable () {
int n;
public void run () {
System.out.println(++n);
}
};
fourTimes(fiveTimes(fiveTimes(r1))).run();
}
public static Runnable twice (Runnable a) {
return add(a,a);
}
public static Runnable fourTimes (Runnable a) {
return twice(twice(a));
}
public static Runnable fiveTimes (Runnable a) {
return add(a,fourTimes(a));
}
public static Runnable add (final Runnable a, final Runnable b) {
return new Runnable () {
@Override
public void run () {
a.run();
b.run();
}
};
}
}

Answer 19

Pseudo código. Utiliza una matriz para forzar una excepción después de 100 elementos que se captura y no hace nada.

function r(array a, int index){
a[index] = a[index-1]+1
print a[index]
r(a, index+1)
}
try{
array a;
a.resize(101)
r(a, 1)
}catch(OutOfBoundsException){
}

EDITAR
Código Java:

public void printTo100(){
int[] array = new int[101];
try{
printToArrayLimit(array, 1);
}catch(ArrayIndexOutOfBoundsException e){
}
}
public void printToArrayLimit(int[] array, int index){
array[index] = array[index-1]+1;
System.out.println(array[index]);
printToArrayLimit(array, index+1);
}

Answer 20

Seguro que hay:

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

Answer 21

Si try and catch es legal, creo que sería fácil y bastante limpio recurse y luego solo dividir por cero cuando hayas terminado. Además de todo eso, siempre es difícil cuando divides por cero tanto por diversión como por ganancias.

public class Main {
public static void main(String[] args) {
count(100);
}
private static int count(int x) {
try {
int value=1/x;
count(x-1);
System.out.println(x);
}
catch (Exception e){
return 0;
}
return 1;
}

Answer 22

Sin condiciones (sin operadores booleanos de acceso directo, sin? Operador, sin excepciones), sin bucles:

import java.util.Vector;
public class PrintOneToHundered {
static int i;
PrintOneToHundered() {}
public String toString() { return ++i+""; }
public static void main(String[] args) {
Vector v1 =new Vector(); v1 .add(new PrintOneToHundered());
Vector v2 =new Vector(); v2 .addAll(v1 ); v2 .addAll(v1 );
Vector v4 =new Vector(); v4 .addAll(v2 ); v4 .addAll(v2 );
Vector v8 =new Vector(); v8 .addAll(v4 ); v8 .addAll(v4 );
Vector v16 =new Vector(); v16 .addAll(v8 ); v16 .addAll(v8 );
Vector v32 =new Vector(); v32 .addAll(v16); v32 .addAll(v16);
Vector v64 =new Vector(); v64 .addAll(v32); v64 .addAll(v32);
Vector v100=new Vector(); v100.addAll(v64); v100.addAll(v32); v100.addAll(v4);
System.out.println(v100);
}
}

Explicación:

• define una clase, cuyo método toString devuelve entradas consecutivas en llamadas repetidas
• crea un vector con 100 elementos, que son instancias de la clase
• imprime el vector (toString-method de un Vector devuelve una cadena de los toString-values ​​de todos sus elementos)

Answer 23

Soy un desarrollador de .Net pero supongo que hay un equivalente Java de esto ...

static int i = 1;
static System.Timers.Timer timer = new System.Timers.Timer();
static void Main(string[] args)
{
timer.Interval = 10; //milliseconds
timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
timer.Enabled = true;
timer.Start();
//let the timer complete... (3000 to show the output stops)
System.Threading.Thread.CurrentThread.Join(3000);
}
static void timer_Elapsed(object sender, ElapsedEventArgs e)
{
Console.WriteLine(i++);
timer.Enabled = (i < 101);
}

Answer 24

System.out.println ("números del 1 al 100")

Answer 25

deja que Arrays haga el trabajo:

public static void main(String[] args) {
Object[] numbers = new Object[100];
Arrays.fill(numbers, new Object() {
private int count = 0;
@Override
public String toString() {
return Integer.toString(++count);
}
});
System.out.println(Arrays.toString(numbers));
}

Answer 26

descargar desde pastebin

System.out.println((new URL("http://pastebin.com/pastebin.php?dl=f722c7eb0")).getContent())

Answer 27

sin ningún bucle y condición:

public static void recfunc(int a[], int i)
{
System.out.println(i);
int s = a[i];
recfunc(a, i + 1);
}
public static void main(String[] args)
{
int[] a = new int[100];
try
{
recfunc(a, 1);
}
catch (Exception e)
{
}
}

con recursividad y sin si creo que uso "?" para el acondicionamiento:

public static int recfunc(int i)
{
System.out.println(i);
return (i < 100) ? recfunc(i + 1) : 0;
}
public static void main(String[] args)
{
recfunc(1);
}

Answer 28

¡NO HAGA ESTO BAJO NINGUNA CIRCUNSTANCIA DE SANE!

public class Fail {
public void thisFails(int x){
System.out.println(x);
Integer[] bigArray = new Integer[9450];
thisFails(x+1);
}
public static void main(String[] args) {
Fail failure = new Fail();
failure.thisFails(1);
}
}

Cuando esto se ejecuta usando 1m de espacio de montón (java -Xmx1m Fail), se agotará en montón en la recursión número 100.

...

Ahora voy a ir a lavarme las manos.

Answer 29

Sí, es posible, pero es terrible. Hay varias maneras de utilizar la recursión o la creación de tipos anidados, con manejo de excepciones para el control de flujo. Esto no tiene aplicación en el mundo real IMO y debe evitarse en código real a toda costa.

Aquí hay un ejemplo que usa instanciación de tipo recursiva con manejo de excepciones para controlar la terminación. Imprime el número en orden descendente, pero sería trivial cambiar a ascendente, simplemente restando 99 (o cualquier constante) del valor que se está imprimiendo.

class PrintVal
{
// called with a list containing as many items as you want, less one...
public PrintVal( List<int> items )
{
System.out.println(items.size()+1); // print the size of the list
try {
items.remove( items.size()-1 ); // will throw when items is empty
new PrintVal( items );
}
catch( Exception ) { /* swallow and terminate */ }
}
}
// setup and invocation that performs the output
ArrayList<int> strList = new ArrayList<int>( new int[99] );
PrintVal instance = new PrintVal( strList ); // all output happens here

Answer 30

public class PrintUptoHundredWithoutIf {
public static void main(String[] args) {
Thread t = new Thread(task());
t.setDaemon(true);
t.start();
sleep((NUMBERS_TO_PRINT * SLEEP_PERIOD_IN_MILLIS)
+ OS_SLEEP_RESPONSE_IN_MILLIS);
}
private static final int SLEEP_PERIOD_IN_MILLIS = 1000;
private static final int NUMBERS_TO_PRINT = 100;
private static final int OS_SLEEP_RESPONSE_IN_MILLIS = 110;
public void printUptoHundred(byte seq) {
int posVal = Math.abs(~seq);
System.out.println(posVal);
sleep(SLEEP_PERIOD_IN_MILLIS);
printUptoHundred((byte) posVal);
}
private static Runnable task() {
return new Runnable() {
@Override
public void run() {
new PrintUptoHundredWithoutIf().printUptoHundred((byte) 0);
}
};
}
private static void sleep(int millis) {
try {
Thread.sleep(millis);
} catch (Exception e) {
e.printStackTrace();
}
}
}