fork download
copy 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.io.*;
  6.  
  7. /* Name of the class has to be "Main" only if the class is public. */
  8. class Ideone
  9. {
  10. 	public static void main (String[] args) throws java.lang.Exception
  11. 	{
  12. 		// your code goes here
  13. 	}
  14. }
  15. /*
  16.  
  17.   ██████╗ ██╗   ██╗ █████╗ ███╗   ██╗████████╗██╗   ██╗███╗   ███╗    ███████╗██████╗  █████╗  ██████╗████████╗██╗   ██╗██████╗ ███████╗
  18.  ██╔═══██╗██║   ██║██╔══██╗████╗  ██║╚══██╔══╝██║   ██║████╗ ████║    ██╔════╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██║   ██║██╔══██╗██╔════╝
  19.  ██║   ██║██║   ██║███████║██╔██╗ ██║   ██║   ██║   ██║██╔████╔██║    █████╗  ██████╔╝███████║██║        ██║   ██║   ██║██████╔╝█████╗
  20.  ██║▄▄ ██║██║   ██║██╔══██║██║╚██╗██║   ██║   ██║   ██║██║╚██╔╝██║    ██╔══╝  ██╔══██╗██╔══██║██║        ██║   ██║   ██║██╔══██╗██╔══╝
  21.  ╚██████╔╝╚██████╔╝██║  ██║██║ ╚████║   ██║   ╚██████╔╝██║ ╚═╝ ██║    ██║     ██║  ██║██║  ██║╚██████╗   ██║   ╚██████╔╝██║  ██║███████╗
  22.   ╚══▀▀═╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝     ╚═╝    ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚══════╝
  23.  
  24.                                                                  PRESENTA
  25.                       _____________________________________________________________________________________________
  26.                         ,
  27.                        '|    |\/| _´_|_ _  _| _    _| _    /\  _ _    ´ _ _  _  _| _  _   /|~) _ |´ _  _  _  _  _\
  28.                        _|_.  |  |(/_ | (_)(_|(_)  (_|(/_  /~~\| (_||_||| | |(/_(_|(/__\  | |~ (_)||(_|(_)| |(_)_\ |
  29.                                                                   |                       \         _|           /
  30.  
  31.  Qué pasa chavales, muy buenas a todos, aquí Crespo comentando (xD willy pls). Con este código, escrito en C++, vamos a hacer que
  32.  este ordenador calcule pi utilizando el método que nuestro Antiguos usaban: calculando polígonos de lado 2*n (dos veces n).
  33.  Si quieres saber las ideas básicas de este algoritmo o no sabes como coj***s has llegado aquí y qué es este código
  34.  hablandome así wtf, te recomiendo pasarte por YouTube y verte este vídeo 
  35.  --> https://y...content-available-to-author-only...u.be/DQ5qqHukkAc   <--.
  36.  Vamos ahora a la miga: Imagina que tenemos DOS polígonos de "2n" lados: Uno inscrito dentro de una circunferencia de radio "r" 
  37.  (es decir, cuyos vertices tocan la circunferencia, está dentro del circulo) y otro circunscrito (es decir, cuyos lados tocan 
  38.  la circunferencia, están por fuera del circulo). 
  39.  En cualquier polígono siempre puedo tirar dos líneas desde el centro a dos vértices contiguos y formar un triángulo 
  40.  (el menor que se puede formar de esta manera):
  41.  
  42.   
  43.                                                           _____________________ (B)
  44.                                                           \     d   |         /
  45.                                                            \________|________/ h2
  46.                                                         (A) \   l   |       /
  47.                                                              \      |      /
  48.                                                               \     |r    /
  49.                                                             h1 \    |    /
  50.                                                                 \   |   /
  51.                                                                  \  |  /
  52.                                                                   \ | /
  53.                                                                    \ /  <----------- al ángulo del triángulo vamos a llamarlo "ang"
  54.                                                                     .
  55.                                                                   centro (O)
  56.  ...donde:
  57.     
  58.     * r   --> radio del circunferencia.
  59.     * h2  --> distancia centro-vertice (OB) del poligono que está CIRCUNSCRITO (que es el poligono está por fuera del círculo,
  60.              con los lados tocando la circunferencia).
  61.     * h1  --> distancia centro-vertice (OA) del polígono que está INSCRITO (que es el poligono está dentro del círculo,
  62.              con los vértices tocando la circunferencia).
  63.     * l   --> es la MITAD del lado del poligono interno.
  64.     * d   --> es la MITAD del lado del poligono externo.
  65.     * ang --> angulo formado por OA y OB. Si el poligono tiene n lados, entonces
  66.               sabemos cuanto vale: una vuelta completa son 2*pi, luego si tiene n lados,
  67.  
  68.                                                     ang = 2*pi/n
  69.  
  70.  Si no ves un carajo del gráfico te recomiendo que estires el tamaño de tu ventana, te llevarás una sorpresa --->
  71.  También es bastante recomendable que, si te quiere enterar bien de esto, te lo dibujes en un papel. Really.
  72.  
  73.  Dos definciones más: sea...
  74.  
  75.     * A_n --> el perímetro del polígono de n lados inscrito.
  76.     * B_n --> el perímetro del polígono de n lados cricunscrito.
  77.  
  78.  A las cuentas: vamos a calcular cuanto vale "l" y cuanto vale "d". Los necesitaremos para saber cuanto son los perímetros 
  79.  que es lo que buscamos, ohú. Por trigonometría básica (definición de seno), "l" verifica:
  80.  
  81.                                                    l = r * sin( pi/n )
  82.  
  83.  ... y "d" verifica:
  84.  
  85.                                                    d = r * tan( pi/n )
  86.  
  87.  Por lo tanto los respectivos perímetros serán el número de lados, n, por el lado, 2l y 2d respectivamente:
  88.  
  89.                   A_n = 2 * n * r * sin( pi/n )        B_n = 2 * n * r * tan( pi/n ) = A_n / cos(pi/n)
  90.  
  91.  Entonces, el perímetro de un polígono con el doble de lados debe verficar:
  92.  
  93.                   A_2n = 4 * n * r * sin( pi/2n )        B_2n = 4 * n * r * tan( pi/2n ) = A_2n / cos(pi/2n)
  94.  
  95.  El objetivo, ahora, es dejar A_2n y B_2n en función de A_n y B_n, es decir, que no dependamos de calcular ángulos (que
  96.  requieren de pi) para saber cuanto vale los perímetros. De este modo partiendo de un polígono muy sencillo cuyas dimensiones puedan
  97.  ser cálculados usando identidades trigonometricas muy sencillas, podemos ir generando los polígonos de más y más lados.
  98.  
  99.  No voy a escribir explicitamente como poner unos en función de los otros; es un desarrollo largo y tengo vídeos que hacer! Pero
  100.  si queréis intentarlo, usad todas las identidades trigonométricas que podáis, especialmente las del angulo doble y ángulo mitad ;)
  101.  
  102.  El resultado es:
  103.  
  104.                                                     B_2n = 2 * A_n * B_n / ( A_n + B_n )
  105.                                                     A_2n = raiz cuadrada de { A_n * B_2n }
  106.  
  107.  Dado que A se acerca al perimetro de la circunferencia desde valores menores y B desde valores mayores, podemos usar estos para 
  108.  calcular los errores del método. Es decir, que, una vez paremos en un cierto número de lados, tomaremos la media de ambos pi's 
  109.  calculados con los diferentes perímetros como el valor de este, y la diferencia de estos como el error que estamos comentiendo;
  110.  así tendremos el rango de valores en lo que el verdadero pi se encuentra.
  111.  
  112.  Quiero agradecer ENORMEMENTE a Diego Soler Polo por ayudarme a encontrar este algoritmo. Sin él, muchos aspectos de este vídeo
  113.  no serían posibles... y este código menos. 
  114.  
  115.  
  116. */
  117.  
  118.  
  119. #include <iostream>  // Cargo librerías (colecciones de funciones ya hechas que hacen cositas): "iostream" me permite sacar texto
  120. #include <cmath>     // y números por el terminal, para que puedas ver el valor de pi, y "cmath" es una colección de funciones
  121. #include <fstream>   // matemáticas que necesito, como elevar al cuadrado y hacer la raiz cuadrada.
  122.  
  123. using namespace std;  // A efectos práticos, esto es para no tener que poner "std" todo el rato.
  124.  
  125. int main(){           // ¡Comenzamos!
  126.  
  127.     // Imprimimos en el terminal... la bienvenida ;)
  128.  
  129.     cout<<endl<<endl;
  130.     cout<<"                       ╔═╗ ┬ ┬┌─┐┌┐┌┌┬┐┬ ┬┌┬┐  ╔═╗┬─┐┌─┐┌─┐┌┬┐┬ ┬┬─┐┌─┐"<<endl;
  131.     cout<<"                       ║═╬╗│ │├─┤│││ │ │ ││││  ╠╣ ├┬┘├─┤│   │ │ │├┬┘├┤"<<endl;
  132.     cout<<"                       ╚═╝╚└─┘┴ ┴┘└┘ ┴ └─┘┴ ┴  ╚  ┴└─┴ ┴└─┘ ┴ └─┘┴└─└─┘"<<endl;
  133.     cout<<"            ______________________________________________________________________     "<<endl<<endl;
  134.     cout<<"                                          PRESENTA...                                  "<<endl;
  135.     cout<<endl;
  136.     cout<<"              ╔═╗┌─┐┬  ┌─┐┬ ┬┬  ┌─┐  ┌┬┐┌─┐  ╔═╗┬       ╔═╗┌─┐┬  ┬┌─┐┌─┐┌┐┌┌─┐┌─┐"<<endl;
  137.     cout<<"              ║  ├─┤│  │  │ ││  │ │   ││├┤   ╠═╝│  ───  ╠═╝│ ││  ││ ┬│ │││││ │└─┐"<<endl;
  138.     cout<<"              ╚═╝┴ ┴┴─┘└─┘└─┘┴─┘└─┘  ─┴┘└─┘  ╩  ┴       ╩  └─┘┴─┘┴└─┘└─┘┘└┘└─┘└─┘"<<endl;
  139.  
  140.     cout<<endl<<"                       Dividiendo perímetros entre diametros desde 2017"<<endl<<endl;
  141.  
  142.     cout<<"_____________________________________________________________________________________________"<<endl<<endl;
  143.     cout<<"                                         ADVERTENCIA                                     "<<endl;
  144.     cout<<"Si está usando este código en un compilador online, puede ser que utilizar un número excesivo"<<endl;
  145.     cout<<" de lados haga que el cálculo necesite tanto tiempo para ser computado que el compilador lo"<<endl;
  146.     cout<<"               aborte automáticamente. En ese caso, pruebe un número menor."<<endl;
  147.  
  148.  
  149.     ////////////////////////////////////////////////////////////////////////////////////////////
  150.     ////////////////////////////////////////////////////////////////////////////////////////////
  151.     ////////////////////////////////////////////////////////////////////////////////////////////
  152.  
  153.     int n = 4  ;         // NÚMERO DE LADOS DEL POLÍGONO. ¡CAMBIAD ESTO!
  154.  
  155.     ///////////////////////////////////////////////////////////////////////////////////////////
  156.     ///////////////////////////////////////////////////////////////////////////////////////////
  157.     //////////////////////////////////////////////////////////////////////////////////////////
  158.  
  159.     // Se expulsa tal número por terminal:
  160.  
  161.     cout<<endl<<"  ╔════════════════════════════════════════════════════════════════════════════════════════╗";
  162.     cout<<endl<<"  ║                 Número de lados máximo del polígono : "<<n;
  163.     cout<<endl<<"  ╚════════════════════════════════════════════════════════════════════════════════════════╝";
  164.  
  165.     double r=1;  // Este es RADIO DE LA CIRCUNFERENCIA. Puedes cambiarlo; el valor de pi no se ve afectado.
  166.  
  167.     double A;    // Defino los Perímetros de los polígonos inscritos y circunscritos.
  168.     double B;
  169.  
  170.     A=4*sqrt(2)*r;  // Cargo los perímetros de un CUADRADO inscrito (A) y circunscrito (B). Estos valores pueden ser fácilmente
  171.     B=8*r;          // obtenidos con el teorema de pitagoras, no pi required.
  172.  
  173.     double m=4;     // Este es el número de lados de los polígonos con los que estamos trabajando.
  174.  
  175.     while (m*2<=n) {  // BUCLE. Si el número de lados del polígono a generar supera el número impuesto por usuario, para.
  176.  
  177.         B=2*A*B/(A+B);      // Calculo de los perímetros con el doble de lados. A cada vuelta los valores de A y B se sobreeescriben.
  178.         A=sqrt(A*B);
  179.  
  180.         m=m*2;              // El número de lados se duplica en cada vuelta.
  181.  
  182.     }                 // Fin de BUCLE
  183.  
  184.     double pi=(  A/2/r + B/2/r  )/2;         // Calculamos pi como la media de los valores de pi de cada perimetro...
  185.     double err = abs(  A/2/r - B/2/r  )/2;   // ... y el error como la resta.
  186.  
  187.     cout.precision(15); // Estos son el número de digitos que quiero que se expulsen por pantalla. Puedes aumentarlo si quieres.
  188.  
  189.     // Sacamos los resultados por pantalla para disfrute del usuario:
  190.  
  191.     cout<<endl<<"  ╔════════════════════════════════════════════════════════════════════════════════════════╗";
  192.     cout<<endl<<"  ║                Con un polígono de "<<m<<" lados, obtenemos:";
  193.     cout<<endl<<"  ║";
  194.     cout<<endl<<"  ║                       "<<"Pi = "<<pi<<"  +/-  "<<err;
  195.     cout<<endl<<"  ║";
  196.     cout<<endl<<"  ║                "<<"o, dicho de otra manera, el valor de pi se encuentra entre";
  197.     cout<<endl<<"  ║                       "<<pi+err<<"   y   "<<pi-err;
  198.     cout<<endl<<"  ╚════════════════════════════════════════════════════════════════════════════════════════╝"<<endl<<endl;
  199.  
  200.  
  201.     return 0;  // Y hemos terminado. Cerramos el chiringuito.
  202.  
  203. }
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
Main.java:119: error: illegal character: '#'
#include <iostream>  // Cargo librer?as (colecciones de funciones ya hechas que hacen cositas): "iostream" me permite sacar texto
^
Main.java:119: error: class, interface, or enum expected
#include <iostream>  // Cargo librer?as (colecciones de funciones ya hechas que hacen cositas): "iostream" me permite sacar texto
         ^
Main.java:120: error: illegal character: '#'
#include <cmath>     // y n?meros por el terminal, para que puedas ver el valor de pi, y "cmath" es una colecci?n de funciones
^
Main.java:121: error: illegal character: '#'
#include <fstream>   // matem?ticas que necesito, como elevar al cuadrado y hacer la raiz cuadrada.
^
Main.java:125: error: class, interface, or enum expected
int main(){           // ?Comenzamos!
^
Main.java:130: error: class, interface, or enum expected
    cout<<"                       ??? ? ??????????? ????  ???????????????? ???????"<<endl;
    ^
Main.java:131: error: class, interface, or enum expected
    cout<<"                       ????? ??????? ? ? ????  ?? ???????   ? ? ??????"<<endl;
    ^
Main.java:132: error: class, interface, or enum expected
    cout<<"                       ???????? ???? ? ???? ?  ?  ???? ???? ? ?????????"<<endl;
    ^
Main.java:133: error: class, interface, or enum expected
    cout<<"            ______________________________________________________________________     "<<endl<<endl;
    ^
Main.java:134: error: class, interface, or enum expected
    cout<<"                                          PRESENTA...                                  "<<endl;
    ^
Main.java:135: error: class, interface, or enum expected
    cout<<endl;
    ^
Main.java:136: error: class, interface, or enum expected
    cout<<"              ???????  ???? ??  ???  ??????  ????       ???????  ????????????????"<<endl;
    ^
Main.java:137: error: class, interface, or enum expected
    cout<<"              ?  ????  ?  ? ??  ? ?   ????   ????  ???  ???? ??  ?? ?? ????? ????"<<endl;
    ^
Main.java:138: error: class, interface, or enum expected
    cout<<"              ???? ????????????????  ??????  ?  ?       ?  ??????????????????????"<<endl;
    ^
Main.java:140: error: class, interface, or enum expected
    cout<<endl<<"                       Dividiendo per?metros entre diametros desde 2017"<<endl<<endl;
    ^
Main.java:142: error: class, interface, or enum expected
    cout<<"_____________________________________________________________________________________________"<<endl<<endl;
    ^
Main.java:143: error: class, interface, or enum expected
    cout<<"                                         ADVERTENCIA                                     "<<endl;
    ^
Main.java:144: error: class, interface, or enum expected
    cout<<"Si est? usando este c?digo en un compilador online, puede ser que utilizar un n?mero excesivo"<<endl;
    ^
Main.java:145: error: class, interface, or enum expected
    cout<<" de lados haga que el c?lculo necesite tanto tiempo para ser computado que el compilador lo"<<endl;
    ^
Main.java:146: error: class, interface, or enum expected
    cout<<"               aborte autom?ticamente. En ese caso, pruebe un n?mero menor."<<endl;
    ^
Main.java:153: error: class, interface, or enum expected
    int n = 4  ;         // N?MERO DE LADOS DEL POL?GONO. ?CAMBIAD ESTO!
    ^
Main.java:161: error: class, interface, or enum expected
    cout<<endl<<"  ??????????????????????????????????????????????????????????????????????????????????????????";
    ^
Main.java:162: error: class, interface, or enum expected
    cout<<endl<<"  ?                 N?mero de lados m?ximo del pol?gono : "<<n;
    ^
Main.java:163: error: class, interface, or enum expected
    cout<<endl<<"  ??????????????????????????????????????????????????????????????????????????????????????????";
    ^
Main.java:165: error: class, interface, or enum expected
    double r=1;  // Este es RADIO DE LA CIRCUNFERENCIA. Puedes cambiarlo; el valor de pi no se ve afectado.
    ^
Main.java:167: error: class, interface, or enum expected
    double A;    // Defino los Per?metros de los pol?gonos inscritos y circunscritos.
    ^
Main.java:168: error: class, interface, or enum expected
    double B;
    ^
Main.java:170: error: class, interface, or enum expected
    A=4*sqrt(2)*r;  // Cargo los per?metros de un CUADRADO inscrito (A) y circunscrito (B). Estos valores pueden ser f?cilmente
    ^
Main.java:171: error: class, interface, or enum expected
    B=8*r;          // obtenidos con el teorema de pitagoras, no pi required.
    ^
Main.java:173: error: class, interface, or enum expected
    double m=4;     // Este es el n?mero de lados de los pol?gonos con los que estamos trabajando.
    ^
Main.java:175: error: class, interface, or enum expected
    while (m*2<=n) {  // BUCLE. Si el n?mero de lados del pol?gono a generar supera el n?mero impuesto por usuario, para.
    ^
Main.java:178: error: class, interface, or enum expected
        A=sqrt(A*B);
        ^
Main.java:180: error: class, interface, or enum expected
        m=m*2;              // El n?mero de lados se duplica en cada vuelta.
        ^
Main.java:182: error: class, interface, or enum expected
    }                 // Fin de BUCLE
    ^
Main.java:185: error: class, interface, or enum expected
    double err = abs(  A/2/r - B/2/r  )/2;   // ... y el error como la resta.
    ^
Main.java:187: error: class, interface, or enum expected
    cout.precision(15); // Estos son el n?mero de digitos que quiero que se expulsen por pantalla. Puedes aumentarlo si quieres.
    ^
Main.java:191: error: class, interface, or enum expected
    cout<<endl<<"  ??????????????????????????????????????????????????????????????????????????????????????????";
    ^
Main.java:192: error: class, interface, or enum expected
    cout<<endl<<"  ?                Con un pol?gono de "<<m<<" lados, obtenemos:";
    ^
Main.java:193: error: class, interface, or enum expected
    cout<<endl<<"  ?";
    ^
Main.java:194: error: class, interface, or enum expected
    cout<<endl<<"  ?                       "<<"Pi = "<<pi<<"  +/-  "<<err;
    ^
Main.java:195: error: class, interface, or enum expected
    cout<<endl<<"  ?";
    ^
Main.java:196: error: class, interface, or enum expected
    cout<<endl<<"  ?                "<<"o, dicho de otra manera, el valor de pi se encuentra entre";
    ^
Main.java:197: error: class, interface, or enum expected
    cout<<endl<<"  ?                       "<<pi+err<<"   y   "<<pi-err;
    ^
Main.java:198: error: class, interface, or enum expected
    cout<<endl<<"  ??????????????????????????????????????????????????????????????????????????????????????????"<<endl<<endl;
    ^
Main.java:201: error: class, interface, or enum expected
    return 0;  // Y hemos terminado. Cerramos el chiringuito.
    ^
Main.java:203: error: class, interface, or enum expected
}
^
46 errors
stdout
copy 
Standard output is empty
https://ideone.com/4aJvWU
language:
Java (HotSpot 12)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!