Desde Okashini os deseo feliz Navidad y felices fiestas. Espero que no os hayáis empachado demasiado en la cena de nochebuena y que vuestro estómago tenga reservas para las comidas y cenas que aún quedan, para después empezar el año 2011 con buen pie. ¡Qué os tráigan muchos regalos!
Imagináos el peor tiempo posible en España. Podemos pensar en pueblos de los valles pirenaicos, Teruel o Palencia, que en ocasiones invernales alcanzan los -20ºC. A lo sumo hablaríamos de unos 30ºC bajo cero y vientos huracanados de 150 kilómetros por hora en las cimas más altas de los pirineos. Aunque es un dato extremo, no tiene nada que ver con el peor tiempo del planeta que se produce, como no, en la Antártida. En base estadounidense McMurdo lo conocen como Condition 1 (Condición 1).
Durante la condición 1, está prohibido salir de la base y para que se declare se debe cumplir alguna de estas razones:
El viento supera los 100 kilómetros por hora (55 nudos).
La visibilidad no supera los 30 metros (100 pies).
La sensación térmica baja de los 60ºC bajo cero.
Todas ellas duras, aunque las dos primeras no son tan extremas si no le añadimos la tercera. Existen bastantes videos, pero sin duda este que os pongo es el más impresionante. Sólo hace falta abrir la puerta para ver que no debe apetecer demasiado salir en esas condiciones.
Teniendo en cuenta que la base McMurdo está a casi a nivel del mar, imagináos que condiciones se pueden llegar a dar en la base Vostok, sitio del cual ya os hablé hace un tiempo y que se considera el más frío del planeta.
Ya os hablé una vez de cuanto se usaba cada letra de media en Español, pero eso solo eran datos. Hoy os traigo algo más entretenido para que comprobéis que porcentaje de letras utilizáis vosotros mismos. Solo tenéis que escribir lo que queráis en el cuadro de texto y podréis ver un gráfico con los porcentajes de cada letra. Si el texto es muy largo seguramente se parezca a la media que os conté la otra vez.
¿Se parece a los porcentajes del otro post? ¿Cuál es la letra que más utilizas?
El programa no cuenta caracteres extraños como á, é, ñ, ç, … ¡viva el inglés! Recordad que necesitáis estar en el navegador y no en el lector RSS para poder probarlo.
Escribe el texto que quieras
Para los que quieran saber como funciona el programa en Javascript, os lo dejo aquí el código, he utilizado jQuery y JSChartspara generar los gráficos. El script principal es el siguiente:
$(document).ready(function(){ var v =new Array(26); var abecedario =new Array('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'); // Cada vez que dejemos de pulsar una tecla
$("#texto_letras_j").keyup(function(){
$("#contador_letras_j").text(""); for(i =0; i < v.length;++i) v[i]=0; var arr = $("#texto_letras_j").val(); var cont =0; // Recorremos todo el texto para analizar cada letra for(i =0; i < arr.length;++i){ // Comprobamos que sea una letra y la añadimos if(/[a-z]/.test(arr.charAt(i))){ ++cont; ++v[arr.charCodeAt(i)-'a'.charCodeAt(0)]; } elseif(/[A-Z]/.test(arr.charAt(i))){ ++cont; ++v[arr.charCodeAt(i)-'A'.charCodeAt(0)]; } } if(cont !=0){ var myData =new Array(26); // Escribimos los resultados for(i =0; i < v.length;++i){ var res =100*v[i]/cont;
myData[i]=[abecedario[i], res];
$("#contador_letras_j").append("<li>"+abecedario[i]+": "+res.toFixed(3)+"%</li>"); } // Generamos el gráfico de JSCharts var myChart =new JSChart('grafico_letras_j','bar');
myChart.setTitle('Uso letras');
myChart.setAxisNameY('%');
myChart.setAxisNameX('Letras');
myChart.setDataArray(myData);
myChart.setBarColor('#42aBdB');
myChart.setBarOpacity(0.8);
myChart.setBarBorderColor('#D9EDF7');
myChart.setBarValues(false);
myChart.setTitleColor('#8C8383');
myChart.setAxisColor('#777E81');
myChart.setAxisValuesColor('#777E81');
myChart.setSize(616,321);
myChart.draw(); } else{
$("#grafico_letras_j").text(""); } }); });
Además, para que funcione, debemos añadir lo siguiente al HTML
El resultado final del HTML será el siguiente:
<scriptsrc="/jquery.js"type="text/javascript"></script> <scriptsrc="/jscharts.js"type="text/javascript"</script> <scriptsrc="/cuenta_letras.js"type="text/javascript"></script> <textareaid="texto_letras_j"></textarea> <divid="grafico_letras_j>Escribe el texto que quieras</div> <ulid="contador_letras_j"></ul>
Los scripts Javascript.
El cuadro de texto (texto_letras_j).
Un div para colocar el gráfico (grafico_letras_j).
Una listay un párrafo (contador_letras_j) para guardar los resultados.
La conjetura de Collatz dice que si cogemos un número al azar y si es par lo dividimos entre 2 o si es impar lo multiplicamos por 3 y le sumamos uno siempre llegaremos a 1 si repetimos este paso indefinidas veces. ¿Cuál es su utilidad? Que yo sepa, ninguna. Ni siquiera se ha demostrado que sea cierto, o falso, pero es entretenido.
¿Cuántas veces creéis que hay que repetirlo con estos números para llegar a 1?
13
23
72
280
Es difícil imaginarse cuantas veces tenemos que repetir la operación para llegar a 1, calcularlo no tanto, pero podemos acabar como el personaje de la tira cómica. A los ordenadores no les cuesta tanto. Podéis probar cuantas veces hacen falta poniendo el número aquí debajo.
Los que leéis desde un lector de feeds es posible que no lo veáis.
Introduce el número que quieras
El 280 parece que tendría más pasos que el 72, pero no. Normalmente contra más grande es el número, más pasos necesita, pero esto no se cumple siempre. Por ejemplo, 1.000 necesita 111 pasos pero 10.000 sólo necesita 29, de hecho, el número que necesita más iteraciones entre 1 y 10.000 (lo máxima que deja calcular nuestro programa) está más o menos por la mitad, 6.171 y 261 iteraciones, os dejo a vosotros que calculéis el máximo hasta 100.000.
Como siempre, información para los más técnicos, aquí tenéis el código Javascript utilizando la librería Jquery que calcula las iteraciones.
<!-- Incluímos la librería de Javascript Jquery. Tenéis que tenerla descargada -->
<script src="/jquery.js" type="text/javascript"></script> <script type="text/javascript"> // Función que calcula si una expresion es numérica function IsNumeric(expression){ return(String(expression).search(/^\d+$/)!=-1); }
$(document).ready(function(){ // Cuando se escribe en #cuadro_Collatz
$("#cuadro_Collatz").keyup(function(){ var n = $(this).val();// Valor del textbox var result; // Cuando no es un número if(!IsNumeric(n)) result ="No es un número"; // Cuando es muy grande (lo he limitado a 10000) elseif(n>10000) result ="No te pases"; // Cuando es menor que 1 (no se puede calcular) elseif(n<1) result ="Sólo números más grandes que 1"; // Cuando se puede calcular else{
result =0; while(n !=1){ ++result; if(n%2) n =3*n +1;// Es impar else n /=2;// Es par } } // Se escribe el resultado en la id #resultado_Collatz
$("#resultado_Collatz").text(result); }); }); </script>
Después del script necesitamos un textbox con identificador #cuadro_Collatz y un span (por ejemplo) con identificador #resultado_Collatz.
<inputid="cuadro_Collatz"size="10"type="textbox"/> <spanid="resultado_Collatz">Introduce el número que quieras</span>
El cifrado César o por desplazamiento es una de las formas más simples de ocultar mensajes, aunque también una de las más fáciles de descifrar. El método no tiene más misterio que desplazar cada letra un número determinado de posiciones dentro del alfabeto de forma cíclica, es decir, si se llega al final se vuelve a empezar por el principio. Por ejemplo, con un desplazamiento de 3 posiciones a la derecha.
Alfabeto sin cifrar:ABCDEFGHIJKLMNÑOPQRSTUVWXYZ. Alfabeto cifrado:DEFGHIJKLMNÑOPQRSTUVWXYZABC.
El origen del cifrado lo encontramos hace más de 2.000 años. Corría el siglo I a.C cuando Julio César utilizó este cifrado con un desplazamiento de 3 posiciones a la derecha para ocultar mensajes en tiempos de guerra.
El descifrado es igual de sencillo si se conoce el número de desplazamientos que hay que realizar. Si no se conoce hay que trabajar algo más, aunque solamente habría que probar todas las combinaciones posibles, probando las primeras palabras hasta encontrar alguna frase coherente, y después traducir todo el texto. Podrían parecer demasiadas combinaciones, pero en el caso de nuestro alfabeto actual son solamente 27 posibilidades, pocas en comparación con otros cifrados. ¿Os imagináis que hubiera la misma cantidad que kanjis japoneses o hanzis chinos?
Vjkf vj le kvokf tzwiruf r kirmvj uvc dvkfuf Tvjri tfe 43 gfjztzfevj uv uvjgcrqrdzvekf r cr uvivtyr.
¿Podéis descifrarlo?
Como curiosidad, este cifrado se utiliza para otros más complejos como el de Vigenère.
¿Conocéis otros sistemas de cifrado?
Para los más técnicos, os dejo un programa en C++ que codifica textos.
// Cifrado César // No se cifran letras con tilde, ñ, ç, ...
void cesar(const string& s, int n){ for(int i =0; i < s.size();++i){ char c = s[i]; if(c >='a' and c <='z'){// Minúsculas if(c+n>'z')cout<<char('a'+c+n-'z'-1); elsecout<<char(c+n); } elseif(c >='A' and c <='Z'){// Mayúsculas if(c+n>'Z')cout<<char('A'+c+n-'Z'-1); elsecout<<char(c+n); } elsecout<< c; } }
int main(){ int n;// Número de posiciones a desplazar cin>> n;
n %=26;
string s; while(cin>> s){
cesar(s, n); cout<<' '; } cout<< endl; }