La forma más creativa de mostrar 42


386

Douglas Adams nació el 11 de marzo de 1952 y murió cuando tenía solo 49 años. En honor a este maravilloso escritor, te desafío a que muestres 42 de la manera más creativa posible.

¡Puede imprimirlo en el registro, a través de algún método complicado, o mostrarlo como arte ASCII, o cualquier cosa! Simplemente invente un método creativo para mostrar 42.

Debido a que este es un concurso de popularidad, la respuesta que tenga más votos positivos para el 11 de marzo, será declarada ganadora.

Nota: esto no es un duplicado. La pregunta que se marcó como duplicado fue una pregunta de control de código cuyo objetivo era escribir código en la salida 42, no encontrar la forma más creativa de mostrarlo .

Ganador: grovesNL! ¡Con un asombroso 813 votos! ¡Felicidades!

Menciones honoríficas:

Mr Lister C 228 Para el uso inteligente de #define

David Carraher Mathematica 45 Para que la complicada y complicada función matemática logre 42

Aschratt Windows Calculator 20 Porque, bueno, es una calculadora de Windows y definitivamente 1337.

f.rodrigues Python 17 Debido al uso inteligente del uso de programas externos. Y MSPaint

Jason C LMGTFY 14 Para el uso de LMGTFY (Permítame buscarlo en Google)

Trimsty Python 12 Para el uso inteligente de un mensaje de error en la salida 42.

Mukul Kumar C ++ 7 Para la buena salida ASCII.

Si crees que hay otra respuesta que vale la pena poner en la lista, ¡coméntala!


66
La vieja pregunta cerrada era un código de trolling, es decir, cualquier cosa que no muestra 42 además de parecer hacerlo o hacerlo de una manera realmente horrible. Este no es código de trolling, es decir, la salida realmente debería ser 42 de una manera agradable. Por lo tanto, no es duplicado.
Victor Stafusa

2
@DanDascalescu Este sitio de SE tiene muchas preguntas sin requisitos estrictos, lo que permite a los usuarios ejercer libertad creativa en sus respuestas. A veces, demasiadas restricciones pueden impedir la expresión de la creatividad
grovesNL

99
La pregunta debe permanecer en 42 votos.
Zero Fiber

28
Marvin The Robot "Publicaría mi brillante respuesta, pero probablemente la rechazaría. Tener razón todo el tiempo es muy deprimente".
Reactgular

3
¿Podemos obtener 42 favoritos?
Milo

Respuestas:


843

Doble brainfuck

           +++++[>++[>+>+        ++>++++>++++>++++>++++++
          >++++++>+++++++        ++>+++++++++<<<<<<<<<-]>>
         >+>+>+> >>>+[<]<        -]>>       >++>-->>+>>++>+
        >--<<<<  <<<.....         .>            ....<......
       ...>...   <<.>....                       >.>>>>>.<.
       <<<<..     ..<....                      >..>>>>>.<
      .<<<<.      >>>.<<.                     >>>>>.<.<
      <<<<<       <.>...>                    >>>.>>>.
     <<<.<        <<<..>>                  .>>>>>.<
    <.<<<         <<...>>                 >>>.<<<
   <..<.          ...>...               <<.>..>.
   >>.<.<<...>>...<<...>>...<         <....>>..
  .<<<.>.>>..>.<<.......<....        .....>...
                 <<.>...            .....>...
                 <......           .>>>.<<..
                 <<.>...          .....>...<......>.>>.<.<<<
                 .>......        ..>>...<<....>>.....>.<..>.

que produce ...

      ++++         +++
    +[>++++    ++[>+<-][
   <]<  -]>   >++    +++
  +.-   ---   ---    ---
 --.+++++++         +++
        +++       .++
        +++      +.-
        ---    -----.--.

que produce ...

6*7=42

92
Siempre pensé que algo estaba fundamentalmente mal con el universo.
mfitzp

147
Debería ser 6*9=42.
Proxy

17
@Proxy: es cierto, pero a veces esas referencias se pierden en los espectadores, incluso a pesar del contexto ... ;-)
grovesNL

19
@IsmaelMiguel: Esa es la base 10 de ustedes ...
Dennis

26
Voté toda la pregunta para que la gente vea esta respuesta.
Michael Stern

329

C

Aquí hay un viejo pero bueno ...

#include <stdio.h>

#define six  1+5
#define nine 8+1

int main()
{
    printf("what do you get when you multiply six by nine?\n");
    printf("%i x %i = %i\n", six, nine, six*nine);
}

Este programa contiene 42 caracteres ASCII diferentes.


15
que es impresionante
ASKASK

41
Me encanta el uso de #define para obtener las matemáticas "correctas" ^^. Eres un hoopy frood.
Olivier Dulac

35
@mikhailcazi: El preprocesador reemplazará esas constantes literalmente, por lo que se six*nineconvierte en 1+5*8+142. Bien hecho, Sr. Lister.
Bodo

77
@canaaerus Mierda, eso es genial. Bravo, señor Lister!
mikhailcazi

44
@mikhailcazi #definefunciona en C ++ exactamente de la misma manera que en C.
Mr Lister

137

Brainfuck

Tomó un tiempo llegar allí, pero me gusta el resultado:

         +++++          +++[>+>++>
        +++>++        ++>+++++>+++++
       +>+++++       ++>+        ++++
      +++ >+++       ++++        ++>+
     +++  ++++                   ++>+
    +++   ++++                  +++>
   +++    ++++                 ++++
  +>+     ++++               ++++
 +++      +>++             ++++
++++++++>+++++++++       ++++
++>+++++++++++++++     +<<<
          <<<<        <<<<
          <<<<       <-]>
          >>>>       >>----.++++<<<<<
          <<>>       >>>>++.--<<<<<<.

Cuando se ejecute, imprimirá 42, por supuesto.


66
Ni siquiera voy a intentar (superar o comprender) ... Eso me recuerda muchas de las entradas que he visto para el Concurso Internacional de Código C Ofuscado.
Isiah Meadows

64
Tengo que admitir que el estilo de fuente del código para mostrar "42" es magnífico ...
WallyWest

15
Ojalá escribieran el kernel de Linux en brainfuck.
devnull

10
Lamentablemente, grovesNL te ha superado .
Blacklight Shining

66
Estoy de acuerdo. Su fuente no se ve tan bien como la mía, pero la salida anidada es una idea realmente genial. También su código tiene más sentido que el mío. Primero diseñé la fuente como arte ascii y luego jugué con el código para que se ajustara al recuento de 220 caracteres del arte ascii, por lo que mi código contiene muchas cosas sin sentido.
Donarsson

133

JavaScript:

var ________ = 0.023809523809523808, ____ = 1, ___ = 0, __ = 0, _ = 1;

       __ -           ___
     /_  |0        //     \\
    /_/   0     //          \\
   /_/_  |0                //
  /_/_   |0              //
 /_/____ |_           //
/________|0        //
         |0     //______________

El resultado es:

42

No está mal, ¿eh? :)

Para las personas que no entienden, en realidad evalúa lo siguiente:

__ - ___ / _ | 0 / _ / 0 / _ / _ | 0 / _ / _ | 0 / _ / ____ | _ / ________ | 0 | 0 0


17
He estado codificando JavaScript durante años, pero no tengo idea de qué es facepalm
Songo

55
@CarlWitthoft Cómo funciona es que _es un nombre de variable válido en JavaScript - y también lo es __, ___, ____, ________.
Cepillo de dientes

3
Muchas gracias. Archivaré esa información (peligrosa :-)) para usarla en el futuro.
Carl Witthoft

2
¡Quién dice que los programadores no son creativos!
Jonathan

1
Como alguien que escribe mucho JavaScript diariamente ... bien hecho, realmente me sorprendiste por un tiempo. Me hubiera encantado pasarlo y asumir algo de esolang.
George Reith

76

C, doce días de estilo navideño

Nueva versión:

main(Z,_){Z?(_=Z[" $X,X3Y<X@Z@[<XHZHX,"
"` \\(Z(X0Z0Z8[@X@^8ZHZHX(Z(`#Y(Z(X3[8"
"\\@_8ZHXHXHX(Z(` \\(Z(X0Z0Z8\\@_8ZIXI"
"X(Z(` \\,X0Z0Z8\\@_8ZHZHX,"])?main(0,_
-32),main(Z+1,_):0:(putchar((_>>3)["kt"
"wy~|tE/42"]-37),(_&7)?main(0,_-1):0);}

Salida:

FFFFF OOOOO RRRR  TTTTT Y   Y    TTTTT W   W OOOOO
F     O   O R   R   T    Y Y       T   W   W O   O
FFFF  O   O RRRR    T     Y        T   W W W O   O
F     O   O R   R   T     Y        T   WW WW O   O
F     OOOOO R   R   T     Y        T   W   W OOOOO

Por cierto, también mira mi respuesta de texto a voz .


Versión original:

main(c,z,_){c==1?main(c+1,0,c^c):c==2?
z=_["##$#%&#%#x'%%()&(%%x$%$((&(*%x'%"
"%((&(+%x'#%((&(%#x"],z?z=='x'?main(4,
_,c*5):main(c+1,z,0),main(c,z,_+1):0:c
==3?(_-2)==3?main(_-1,_,32):(main(c+1,
c,((2+c)*(z-35)+_)["six*nine= {   }  "
"   ;      _   ( ) [ 3 ]do {;=0xDA"]==
32?32:043),main(c,z,_+1)):putchar(_);}

El resultado es:

##### ##### ####  ##### #   #       ##### #   # #####
#     #   # #   #   #    # #          #   #   # #   #
####  #   # ####    #     #           #   # # # #   #
#     #   # #   #   #     #           #   ## ## #   #
#     ##### #   #   #     #           #   #   # #####

Espaciado alternativo, si te sientes de mal gusto:

        main(c     ,z,_){c==01?
       main(c+     1,0,c^c):c==2
      ?z=_["#"     "#$#%&#%#x'%%"
     "()&(%%x"             "$%$("
    "(&(""*%x"             "'%%("
   "(&(" "+%x"             "'#%("
  "(&("  "%#x"             ],z ?z
 =='x'?main(4,_     ,c*5):main(c
 +1,z,0),main(c    ,z,_+1):00:c
 ==3?(_+-2)==3?    main(_-1,_,
         32):(     main(
         c+1,c     ,((2+
         c)*(z     -35)+
         _)[""     "six"
         "*ni"     "ne= {   }   "
         "  ;"     "      _   ( "
         ") ["     " 3 ]do {;"]==
         32?32     :043),main(c,z
         ,_+1)     ):putchar(_);}

El programa es una declaración recursiva única. Lo hice al estilo de mi programa favorito de C ofuscado, Doce días de Navidad (compilar, preparar la mente para volar, correr).


CÓMO

Además, dado que este parece un lugar tan bueno como cualquier otro, aquí hay una guía que describe cómo hacer este tipo de programa. Esta guía utiliza la versión original anterior como ejemplo. Aparte del primer bit con las letras mayúsculas, son pasos generales:

INICIAL: Primero, comencé haciendo las letras mayúsculas:

##### ##### ####  ##### #   #       ##### #   # #####
#     #   # #   #   #    # #          #   #   # #   #
####  #   # ####    #     #           #   # # # #   #
#     #   # #   #   #     #           #   ## ## #   #
#     ##### #   #   #     #           #   #   # #####

Luego hice una lista numerada de los patrones únicos en cada fila de caracteres de 5 columnas:

0: *****  
1: **** 
2: *   * 
3:       
4: *     
5:   *   
6:  * *  
7: * * * 
8: ** ** 

Y así, cada una de las filas de texto de 5 píxeles se convierte en una serie de 9 números:

00000 00000 11111 00000 22222 33333 00000 22222 00000
44444 22222 22222 55555 66666 33333 55555 22222 22222
11111 22222 11111 55555 55555 33333 55555 77777 22222
44444 22222 22222 55555 55555 33333 55555 88888 22222
44444 00000 22222 55555 55555 33333 55555 22222 00000

Para la ofuscación (y la facilidad de programación) agregamos el carácter '#' a los números. En el siguiente programa, patternses la matriz de patrones de píxeles, y lineses la matriz ofuscada de códigos de patrón para cada línea, terminada por una 'x'. Para mayor ofuscación, definimos píxeles "en" patternscomo cualquier carácter que no sea un espacio; esto nos permite poner más texto engañoso en pattern:

#include <stdio.h>

char pattern[] = 
  "six*n"
  "ine= "
  "{   }"
  "     "
  ";    "
  "  _  "
  " ( ) "
  "[ 3 ]"
  "do {;";

char lines[] =
  "##$#%&#%#x"
  "'%%()&(%%x"
  "$%$((&(*%x"
  "'%%((&(+%x"
  "'#%((&(%#x";

void printpattern (char c) {
  int n;
  for (n = 0; n < 5; ++ n)
    putchar(pattern[5*(c-'#') + n]==32?32:'#');
  putchar(' ');
}

int main () {
  char *ptr = lines;
  while (*ptr) {
    while (*ptr != 'x')
      printpattern(*(ptr++));
    putchar('\n');
    ++ ptr;
  }
}

PASO 1: El siguiente paso implica algunas tareas:

  • Elimine todos los bucles y use la recursividad.
  • Cambie todas las funciones (excepto main) al formulario int function (int, int)y use los mismos nombres de parámetros para cada una. Las razones se aclararán más adelante.
  • Cambie mainal formulario int main (int, int, int)y nombre los dos últimos parámetros de la misma manera que los nombres de los parámetros de su función.
  • Reemplace todas las referencias a constantes de cadena con las cadenas mismas; y use cada cadena solo una vez si es posible.
  • La inclusión se puede eliminar; es innecesario para int putchar (int).

También podemos aprovechar la característica extraña de C, que a[b]es equivalente b[a]a ofuscarnos aún más.

int printpattern (int z, int _) {
  if (_==5)
    putchar(' ');
  else{
    putchar((5*(z-'#') + _)["six*nine= {   }     ;      _   ( ) [ 3 ]do {;"]==32?32:'#');
    printpattern(z, _+1);
  }
  return 0;
}

// z ignored, _ is index
int printtext (int z, int _) {
  z = _["##$#%&#%#x'%%()&(%%x$%$((&(*%x'%%((&(+%x'#%((&(%#x"];
  if (z) {
    if (z == 'x')
      putchar('\n');
    else
      printpattern(z, 0);
    printtext(z, _ + 1); // first parameter arbitrary
  }
  return 0;
}

int main (int c, int z, int _) {
  printtext(0, 0);
}

PASO 2: A continuación, utilice los operadores ?:y ,para transformar cada función en una sola returndeclaración. Estoy ilustrando esto por separado de lo anterior porque aquí es donde las cosas comienzan a ser confusas de ver. Recuerde que putchar()devuelve un int, y ?:tiene prioridad sobre ,:

int printpattern (int z, int _) {
  return _==5 ?
    putchar(' ')
  :
    (putchar((5*(z-'#') + _)["six*nine= {   }     ;      _   ( ) [ 3 ]do {;"]==32?32:'#'),
     printpattern(z, _+1));
}

// z ignored, _ is index
int printtext (int z, int _) {
  return
    z = _["##$#%&#%#x'%%()&(%%x$%$((&(*%x'%%((&(+%x'#%((&(%#x"],
    z ?
      z == 'x' ?
        putchar('\n')
      :
        printpattern(z, 0)
      ,
      printtext(z, _ + 1)
    :
    0;
}

int main (int c, int z, int _) {
  printtext(0, 0);
}

PASO 3: Ok. El siguiente paso es grande. Todas las funciones son ahora una sola declaración de la misma forma. Ahora podemos combinarlos todos en una sola función, identificando cada uno por un número, esencialmente convirtiendo todo el programa en una sola función recursiva. Tenga en cuenta que el primer parámetro mainserá 1 cuando el programa se ejecute sin argumentos, por lo que ese debería ser nuestro estado inicial.

Además, dado que nuestro parámetro cto maines nuestra variable de estado, conocemos su valor en todo momento, y podemos ofuscarnos un poco más reemplazando las constantes enteras con sus valores en términos de c(por ejemplo, cuando sabemos que ces 2, podemos reemplazar 5 con c+3). También se pueden hacer otras pequeñas ofuscaciones (por ejemplo, las reemplacé '#'por 35y 043):

int main (int c, int z, int _) {
  switch (c) {
  case 1: // main
    return main(c+1, 0, c^c); // (2, 0, 0)
  case 2: // printtext
    return
    z = _["##$#%&#%#x'%%()&(%%x$%$((&(*%x'%%((&(+%x'#%((&(%#x"],
    z ?
      z == 'x' ?
        putchar('\n')
      :
        main(c+1, z, 0) // c+1==3
      ,
      main(c, z, _ + 1)
    :
    0;
  case 3: // printpattern
    return (_-2)==3 ? // _==5
    putchar(' ')
    :
     (putchar(((2+c)*(z-35) + _)["six*nine= {   }     ;      _   ( ) [ 3 ]do {;"]==32?32:043),
     main(c, z, _+1));
  }
}

PASO 4: Finalmente, elimine el switchbloque utilizando una serie de ?:operadores. También podemos eliminar las intdeclaraciones, ya que C las usará por defecto, así como la returnpropia (que generará una advertencia en el peor de los casos). Después de esto, nuestro programa es una única función recursiva con una declaración. Muy bien, ¿verdad?

Editar: lo reemplacé putchar()con a mainy c==4debajo; porque lo pensé en el último momento:

main (c, z, _) {
  c == 1 ?
     main(c+1, 0, c^c)
  : c == 2 ?
    z = _["##$#%&#%#x'%%()&(%%x$%$((&(*%x'%%((&(+%x'#%((&(%#x"],
    z ?
      z == 'x' ?
        main(4,_,c*5)
      :
        main(c+1, z, 0) 
      ,
      main(c, z, _ + 1)
    :
    0
  : c==3 ?
    (_-2)==3 ? 
    main(_-1,_,32)
    :
    (main(c+1,c,((2+c)*(z-35) + _)["six*nine= {   }     ;      _   ( ) [ 3 ]do {;"]==32?32:043),
      main(c, z, _+1))
  : // c==4
    putchar(_);
}

Si desea agregar un poco de estilo, puede usar números más interesantes ce incluso basar los cheques en otros números (por ejemplo, para el c==2caso, zse ignora y está disponible, por lo que en lugar de llamar main(2,z,_), puede llamar main(-97,_,_)y reemplazar c==2con c<-z). Ser creativo; Las posibilidades son infinitas.

ACABADO: El paso final, entonces, es organizar el texto en algún patrón creativo, ¡y listo! Puede ajustar un poco el código para ayudar con el formateo (por ejemplo, agregué algunos datos adicionales al final de la patternscadena en el programa publicado para ayudar a obtener la longitud correcta de la línea). Las señoras seguramente estarán llenas de complementos.


¿Debo quitar la guía? Me gusta el misterio sin él.
Jason C

He actualizado la respuesta con una nueva versión que es más corta e imprime las letras en la salida. La guía se basa en la versión original (aún presente). La nueva versión almacena la salida como datos RLE; La primera cadena larga son los datos.
Jason C

2
Quiero hacer +1 en esta respuesta dado que se tomó el tiempo para explicar el "cómo" detrás de su solución, pero actualmente tiene 42 rep. Y no quiero estropear eso. ;)
Adam Parkin

44
@AdamParkin Jaja! Bueno, aquí, si llega a 43, es tu trabajo rechazarlo.
Jason C


63

Java

(o C ++, el código es casi similar)
Usando funciones de cadena, ¡así que no olvide incluir su biblioteca!

PD: Sé que es largo, pero se supone que es creativo, ¿verdad? Y de todos modos, no es un "menor byte-gana".

String s = "Hitchhiker's Guide to the Galaxy";
String s2 = "Don'tPanic";
String s3 = "The Restaurant at the End of the Universe.";

int arthur_dent = s.length();
int ford_prefect = s2.length();
int zooey_deschanel = s3.length();
int vogon_poetry = arthur_dent + ford_prefect;

System.out.println("         " + vogon_poetry + "       " + zooey_deschanel + " " + zooey_deschanel); //in case you're confused, I'm using Zooey to print the big '2', and Vogons to print the big '4'.
System.out.println("       " + vogon_poetry + vogon_poetry + "     " + zooey_deschanel + "     " + zooey_deschanel);
System.out.println("     " + vogon_poetry + "  " + vogon_poetry + "    " + zooey_deschanel + "       " + zooey_deschanel);
System.out.println("   " + vogon_poetry + "    " + vogon_poetry + "            " + zooey_deschanel);
System.out.println(" " + vogon_poetry + "      " + vogon_poetry + "          " + zooey_deschanel);
System.out.println(vogon_poetry + " " + vogon_poetry + " " + vogon_poetry + " DA " + vogon_poetry + "     " + zooey_deschanel);
System.out.println("         " + vogon_poetry + "     " + zooey_deschanel);
System.out.println("         " + vogon_poetry + "    " + zooey_deschanel + " " + zooey_deschanel + " " + zooey_deschanel + " " + zooey_deschanel);

Aquí está la salida:

         42       42 42
       4242     42     42
     42  42    42       42
   42    42            42
 42      42          42
42 42 42 DA 42     42
         42     42
         42    42 42 42 42 

¡Imagina mi miseria cuando conté y descubrí que "El restaurante del fin del universo" tenía 41 personajes! : / Suspiro.


2
¿Por qué hay un 'DA' en la salida? es intencional?
Mhmd

14
@ user689 D ouglas A dams :)
mikhailcazi

99
En realidad, 41 también es DA de alguna manera (D es la cuarta letra, A es la primera). ¡Alegrarse!
vadchen

11
4-1 = 3 lo que significa, • _ •) (• _ •)> ⌐ ■ - ■ (⌐ ■ _ ■) Half Life 3 confirmado.
Mohd Abdul Mujib

17
El restaurante al final del universo tiene 41 caracteres + "\ 0": DDD
enterx

59

Mathematica

Toma 1

Con algo de trabajo, debería ser capaz de jugar golf un poco. :)

En InputForm:

answer[ultimateQuestion[Life,theUniverse,Everything]] =
  Times[Plus[-1,Limit[Power[Plus[1,Times[Complex[0,1],
  Power[n,-1],Pi]],n],Rule[n,DirectedInfinity[1]]]],Sqrt[-1]^2,
  Times[Rational[1,2],Plus[-1,Fibonacci[4]],Fibonacci[2]],
  Binomial[3,2],LucasL[4]]

En TraditionalForm:

cuarenta y dos

Pruebas:

answer[ultimateQuestion[Life,theUniverse,Everything]] 

42


Tomar 2

Nota: Los números se hicieron de la siguiente manera.

  • "42" se imprimió por primera vez en la pantalla en letra muy grande, con los ejes mostrados, de modo que se pudieran identificar las coordenadas de los puntos clave.
  • Otro "4" se dibujó una línea recta amplia que conecta los puntos clave respectivos. Se superpuso al "4" previamente dibujado para verificar la precisión. El "2" se dibujó como una curva BSpline. Algunos de los puntos clave, que ahora eran puntos de control, tuvieron que establecerse en posición por prueba y error para obtener las curvas deseadas.
  • Se agregó una tercera coordenada (siempre cero) a la línea y BSplineCurve para habilitar la visualización en 3D.

answer[ultimateQuestion[Life,theUniverse,Everything]]  = 
 Table[With[{v = RotationTransform[θ, {0, 0, 1}][{3, 0, -.2}]},
   Graphics3D[{Thickness[.06], CapForm["Round"],
     Tube[Line[{{-67, 0, -44}, {-30, 0, -44}}], 10],
     Tube[
      Line[{{-25, 0, -12}, {-100, 0, -12}, {-52, 0, 70}, {-45, 0, 70}, {-45, 0, -43}}], 10], 
     Tube[BSplineCurve[l = {{27, 0, 52}, {27, 0, 57}, {57, 0, 85}, {113, 0, 40}, 
     {12, 0, -45}, {35, 0, -45}, {90, 0, -45}, {90, 0, -45}, {92, 0, -35}}], 10]},
     Boxed -> False, PlotRange -> 100, ImageSize -> 250, SphericalRegion -> True, 
     ViewPoint :> v, 
     PlotRangePadding -> 10]],(*{θ,0,2Pi,Pi/24},*){θ, -Pi/2, -Pi/2 + 2 Pi, Pi/24}]

Export["theMeaningOfLife.gif", answer[ultimateQuestion[Life,theUniverse,Everything]] ]

tomar 2


1
Afortunadamente no es una pregunta de golf :) parece ser una buena ayuda de la creatividad matemática allí ...
cormullion

1
Gracias. Mathematica ciertamente ofrece muchas opciones para explorar.
DavidC

3
Agradable; Ojalá pudiera retroceder en el tiempo y poner ese gráfico en geocities.com/42, jaja.
Jason C

57

Parece apropiado:

grep -i "DON'T" /bin/lesspipe | wc -l ; grep -i "PANIC" /usr/share/pyshared/mx/Log.py | head -n 1 | cut -d '=' -f 2 | tr -d ' '

Salida:

4
2

Ubuntu 12.04, escritorio de 64 bits


23
+1 para no entrar en pánico
Milo

Sería un bash-ism, pero echo $(grep -i ... tr -d ' ') | sed 's/ //g'lo pondría todo en una línea. También podría usar comillas inversas en lugar del $()formulario, pero es más difícil poner un comentario aquí.
Mike Renfro


@MikeRenfro ¿Cómo es eso un bashishm? $()está especificado por el estándar POSIX .
nyuszika7h 01 de

Correcto, obviamente estoy desactualizado. La última vez que lo revisé (hace muchos años), pensé que era. Puede haber estado equivocado entonces, también.
Mike Renfro

45

Calculadora de Windows

Multiplicar Pi con 13.37 e ignorar el decimal:P

Cuarenta y dos


17
+1 porque las fracciones definitivamente no son 1337.
Jason C

1
La calculadora de un programador hubiera sido mejor, pero esa calculadora no tiene (pastel)
Mukul Kumar

1
1337 * math.pi / 100
cromano

11
round (1337 * math.pi / 100) <- Un pequeño cambio ya que el pastel es redondo.
Kevin

41

Pitón

Supongo que solo funciona en Windows 7.

import win32api, win32con, win32gui
from time import time, sleep
import os

w = { 1:[(358, 263), (358, 262), (358, 261), (359, 261), (359, 262), (359, 264), (359, 266), (359, 270), (359, 282),
     (358, 289), (357, 308), (356, 319), (355, 341), (355, 351), (355, 360), (355, 378), (355, 388), (354, 397),
     (354, 406), (354, 422), (354, 428), (354, 436), (354, 438), (354, 439), (354, 440), (355, 440), (356, 439),
     (357, 439), (358, 438), (360, 438), (362, 437), (369, 437), (372, 437), (381, 437), (386, 437), (391, 437),
     (397, 436), (411, 436), (419, 435), (434, 435), (442, 435), (449, 434), (456, 434), (468, 434), (473, 435),
     (480, 436), (483, 436), (485, 436), (487, 437), (488, 437), (488, 438), (488, 439), (487, 440), (486, 440),
     (485, 440), (484, 440), (483, 439), (483, 437), (481, 431), (481, 427), (481, 420), (481, 413), (483, 396),
     (485, 387), (488, 367), (491, 356), (493, 345), (500, 321), (503, 310), (507, 299), (514, 280), (517, 272),
     (520, 266), (523, 260), (524, 258), (524, 259), (524, 261), (524, 265), (524, 269), (523, 275), (522, 289),
     (521, 297), (518, 315), (516, 324), (515, 334), (513, 345), (509, 368), (507, 382), (502, 411), (500, 426),
     (498, 440), (495, 453), (491, 478), (489, 491), (485, 517), (483, 530), (481, 542), (479, 552), (476, 570),
     (475, 577), (474, 588), (473, 592), (473, 595), (473, 597), (473, 600), (473, 601), (473, 602), (473, 601),
     (474, 599), (475, 597), (476, 594), (478, 587)],
  2:[(632, 305), (634, 306), (636, 309), (639, 314), (641, 319), (645, 330), (647, 337), (649, 353), (649, 362),
     (649, 372), (649, 384), (645, 409), (639, 436), (636, 448), (632, 459), (627, 470), (623, 479), (613, 497),
     (608, 503), (599, 512), (595, 514), (591, 514), (587, 513), (581, 504), (578, 498), (576, 483), (575, 476),
     (575, 469), (579, 454), (582, 447), (591, 436), (595, 432), (600, 430), (605, 429), (617, 432), (624, 437),
     (639, 448), (646, 455), (654, 461), (662, 469), (679, 484), (686, 491), (702, 504), (710, 509), (718, 512),
     (727, 514), (744, 515), (752, 515), (767, 512), (774, 510), (779, 508), (783, 505), (788, 499), (789, 495),
     (789, 486)] }

def d( x1, y1, x2, y2 ):
    win32api.SetCursorPos((x1, y1))
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
    win32api.SetCursorPos((x2, y2))
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, 0, 0, 0, 0)
    sleep(0.01)

def p( l1 ):
    l2 = [""]
    l2.extend(l1)
    l1.append("")
    l3 = zip(l2, l1)
    l3.pop(0)
    l3.pop(-1)
    for n in l3:
        d(n[0][0], n[0][1], n[1][0], n[1][1])

os.startfile("C:\Windows\system32\mspaint.exe")
sleep(0.5)
win32gui.ShowWindow(win32gui.GetForegroundWindow(), win32con.SW_MAXIMIZE)
sleep(0.5)

for n in w:
    p(w[n])

El resultado es abrir Pintura y pintar 42 como mano libre.

42


1
No tengo win32api :( Quería ver eso ... Todavía +1 aunque: D
Timtech

No uso Windows, así que no puedo ejecutarlo; Pero tu camino es brillante .
pushpen.paul

3
Quería votar esto, pero esto tiene exactamente 42 votos positivos, no quiero arruinar eso.
Rohcana

39

Java (Swing)

Esto mostrará un cuadro dibujando la respuesta . Solo se usa 42para valores.

public        class         FourtyTwo{ public
static         void         main(String[]args)
{  new        javax                    .swing.
JFrame        () {{                    setSize
(42 /(        42/42                    +42/42)
*42/ (        42/42                    +42/42)
,42/(42/ 42+42/42)*         42/(42/42+42/42));
}public void paint(         java.awt .Graphics
  g){g.drawPolygon(         new int[]{42,42,42
              + 42+         42,42+
              42+42         ,42+42
              +42 +         42,42+
              42+42         +42,42
              + 42+         42,42+42+42,42+42,
              42+42         },new int[]{42,42+
              42+42         +42,42+42+42+42,42

+42+42+42+42+42,                  42+42+
42+42+42+42,42,42,               42+42+42
,42 +        42+42              ,42}, (42/
42+42        /42)*              (42/  42 +
42/42        + 42/             42 +    42 /
42+42        /42))            ;g.drawPolygon
( new        int[]           {42+42+42+42+42,
42+42        +42 +           42+42      , 42+
42+42        + 42+          42+42        + 42,
42+42        +42 +          42+42        +42 +
42,42+42+42+42+42,         42+42          + 42+
42+42,42+ 42+42+           42+42          +42 +

42+42,42+42+42+42+42+42+42+42,42+42+42+42+42+42,
42+42+42+42+42+42,42+42+42+42+42+42+42+42,42+42+
42+42+42+42+42+42},new int[]{42,42 +42,42+42,42+
42+42,42+42+42,42+42+42+42+42+42,42+42+42+42+42+
42,42+42+42+42+42,42+42+42+42+42,42+42+42+42,42+
42+42+42,42},(42/42+42/42+42/42)*((42/42+42/42)*
(42/42+42/ 42)));};}.setVisible(42*42*42!=42);}}

14
+1 para el bloque "I-just-pasar-una-tonelada-de-tiempo-formateando-esto-y-realmente-no-siento-como-trabajar-las-sobras" en la parte inferior, jaja.
Jason C

3
@JasonC ¡Eso es exactamente lo que pensaba! ; D ¡Mañana, trabajaré en un programa que formatea código para el arte ASCII y seré rico!
bobbel

Empecé a hacer esto con el mío y rápidamente me di por vencido. Buen trabajo.
ChiefTwoPencils

28

Mathematica

WolframAlpha["meaning of life", {{"Result", 1}, "Content"}]

42

aunque creo que es trampa, realmente, ya que está codificado. Y no muy creativo, por mi parte ... :)


28

Rubí

Es bien sabido lo que obtienes si multiplicas seis por nueve . Esto da una solución:

puts (6 * 9).to_s(13)

Pitón

Una variante de la fórmula autorreferencial de Tupper :

# Based loosely on http://www.pypedia.com/index.php/Tupper_self_referential_formula
k = 17 * (
    (2**17)**0 * 0b11100000000000000 +
    (2**17)**1 * 0b00100000000000000 +
    (2**17)**2 * 0b00100000000000000 +
    (2**17)**3 * 0b11111000000000000 +
    (2**17)**4 * 0b00100000000000000 +
    (2**17)**5 * 0b00000000000000000 +
    (2**17)**6 * 0b01001000000000000 +
    (2**17)**7 * 0b10011000000000000 +
    (2**17)**8 * 0b10011000000000000 +
    (2**17)**9 * 0b01101000000000000 +
0)
# or if you prefer, k=int('4j6h0e8x4fl0deshova5fsap4gq0glw0lc',36)

def f(x,y):
    return y // 17 // 2**(x * 17 + y % 17) % 2 > 0.5
for y in range(k + 16, k + 11, -1):
    print("".join(" @"[f(x, y)] for x in range(10)))

Salida:

@  @   @@ 
@  @  @  @
@@@@@    @
   @   @@ 
   @  @@@@

2
Desafortunadamente, como señala su enlace de Wikipedia, el ADN rechaza el primer método para producir 42: "Puede que sea un caso lamentable, pero no escribo chistes en la base 13."
LSpice

26

Javascript

alert((!![]+ -~[])*(!![]+ -~[])+""+(!![]+ -~[]))

3
Otro que me dio un momento WTF hasta que me di cuenta true == 1.
George Reith

12
¡ALERTA! ¡PILARES ASCII CATERPILLARS! ¡UTILICE PRECAUCIÓN EXTREMA!
Jason C

Use en []lugar de ""( [] == '')! alert((!![]+-~[])*(!![]+-~[])+[]+(!![]+-~[]))
Cepillo de dientes

(!-[] === true) && (!~[] === false). También puede sustituir {}por [].
Cepillo de dientes

1
¿Qué tal (!!{}+!-[]<<-~{})+[]+(!-[]+-~[])?
Cepillo de dientes


23

Adelante:

SCR # 1
 0 ( FORTY-TWO @ ES-FORTH )
 1 HEX 0 24 -31 21 -31 31 -31
 2 31 -14 51 11 -11 51 11 -11 23 31
 3 : T SWAP 0 DO DUP EMIT LOOP DROP ;
 4 : K BEGIN DUP WHILE DUP 0< IF CR
 5  ABS THEN 10 /MOD 20 T A0 T
 6  REPEAT DROP ;
 7 K CR

Que 1 CARGA salidas:

   █  ███
 █ █     █
 █ █     █
 ████   █
   █   █
   █  █
   █  ████


21

R

sum(as.numeric(factor(unlist(strsplit(gsub(" |[.]","","D. ADAMS"),"")),levels=LETTERS)))

Resultado:

42

18

Java

public class MainProgram {    
    public static void main(String[] args) {
        int[] the      = { 'T', 'h', 'e' };
        int[] most     = { 'M', 'o', 's', 't' };
        int[] creative = { 'C', 'r', 'e', 'a', 't', 'i', 'v', 'e' };
        int[] way      = { 'W', 'a', 'y' };
        int question   = '?';

        double x = -3.18906605923E-2;

        int The      = 0;
        int Most     = 0;
        int Creative = 0;
        int Way      = 0;

        for(int i : the) {
            The += i;
        }
        for(int i : most) {
            Most += i;
        }
        for(int i : creative) {
            Creative += i;
        }
        for(int i : way) {
            Way += i;
        }
        System.out.println((int)((The*x)-(Most*x)-(Creative*x)-(Way*x)-(question*x)));      
    }//SSCE
}//good1

Salida:

42


2
+1 por emplear una ecuación lineal interesante, ¡buen trabajo!
recursion.ninja

17

SWI-Prolog, alguien?

?- X.

Salida:

% ... 1,000,000 ............ 10,000,000 years later
% 
%       >> 42 << (last release gives the question)

Esto es aún más vago que el de Mathematica-llamando-Wolfram-Alpha, ¡pero oye!


3
Bienvenido a Code-Golf! ¡No olvides agregar una explicación sobre por qué esta respuesta es creativa!
Justin

3
@Quincunx Es un huevo de pascua en SWI-Prolog.
svick

15

Shell de Linux

Aquí hay algo que escribí en 1999 y usé como mi firma de Usenet en ese entonces.

echo "what is the universe"|tr "a-z " 0-7-0-729|sed 's/9.//g;s/-/+/'|bc

Editar: ¡Ja! Esta fue la respuesta número 42.


15

Versión PHP:

 echo strlen("Douglas Adams")+strlen("born on")+array_sum(array(1,1,0,3,1,9,5,2));
 /* array(1,1,0,3,1,9,5,2) => March 11, 1952 */

Versión de JavaScript:

 console.log("Douglas Adams".length + "born on".length + [1,1,0,3,1,9,5,2].reduce(function(previousValue, currentValue, index, array){return previousValue + currentValue;}));

 /* [1,1,0,3,1,9,5,2] => March 11, 1952 */

Salida:

 42

2
Nunca entenderé cómo cualquier humano en su sano juicio puede escribir una fecha en este orden. El hecho de que tenga que poner un comentario allí demuestra lo inútil que es este formato.
bodo

1
@canaaerus Acabo de usar la fecha en un formato específico para que un programa pueda procesarla 42. Intenté varias otras formas legibles por humanos, y esto fue lo más cercano que pude transformar la fecha para llegar a la solución.
palerdot

24
@canaaerus Nunca entenderé cómo los estadounidenses también pueden escribir fechas mm/dd/yy. Si dices 04/03/11, lo leería el 4 de marzo de 2011, no el 3 de abril.
Cepillo de dientes

77
@palerdot. Hasta donde yo sé, solo los estadounidenses (y ocasionalmente canadienses) escriben las fechas de esa manera extraña, confusa y "endianiana".
TRiG

2
@TRiG: ¿Qué esperas? Nosotros, aparte de aquellos de nosotros en los campos de la ciencia y la ingeniería, evitamos también el sistema métrico más intuitivo y lógico.
ChiefTwoPencils

15

corriente continua

$ dc <<< "1 8 sc 1 5 lc *++p"
42

Intentando multiplicar 1+8y 5+1obtener 42. Parece que la ignorancia de la precedencia del operador condujo a 42.


Pitón

>>> p = lambda x: x%2!=0 and True<<x
>>> sum(p(i) for i in range(0,6))

Salida: 42


golpetazo

(Multiplicando 6por 9)

$ echo "obase=13;6*9"|bc|figlet
 _  _  ____
| || ||___ \
| || |_ __) |
|__   _/ __/
   |_||_____|

C

#include <stdio.h>
int main(){printf("%d",fprintf(fopen("/dev/null","w"), "so-popularity-contest\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"));}

Salida: 42

  • ¿Notó el uso de caracteres de retroceso?
  • ¿Sabes en qué resultan esos?

No ... por favor explique!
Antonio Ragagnin

Los caracteres de retroceso rellenan la cadena a una longitud de 42 bytes. Entonces, primer fopen se usa para abrir el dispositivo nulo para acceso de escritura. Luego, fprintf escribe 42 bytes en nulo, devolviendo los números de bytes escritos. Finalmente, ese 42 está formateado por la cadena de formato "% d" de la función printf para mostrar 42. ¡Me gusta!
CasaDeRobison

12

Brainf ** k

- [   --
- -     -
>+<]  >+
  .   --.

¿Depende esto de un desbordamiento en el intérprete?
Cruncher

Sí, parece que supone un desbordamiento a 255. 255/5 = 51 + 1 = 52, que es el código de carácter para 4. No creo que todos los intérpretes hagan esto, pero +1
Cruncher

@Cruncher Necesita celdas de ajuste de 8 bits. Este es el tipo más común.
Timtech

12

C ++

#include<iostream>
#include<conio.h>
using namespace std;
int main()
{
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)66<<(char)73<<(char)82;
    cout<<(char)84<<(char)72<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)68<<(char)69;
    cout<<(char)65<<(char)84<<(char)72;
    cout<<(char)32<<(char)32<<'\n';
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<(char)95;
    cout<<(char)95<<(char)95<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)95<<(char)95;
    cout<<(char)95<<(char)95<<(char)95;
    cout<<(char)95<<(char)32<<'\n';
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)47<<(char)32;
    cout<<(char)32<<(char)32<<(char)124;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)124<<(char)32<<(char)32;
    cout<<(char)95<<(char)95<<(char)32;
    cout<<(char)32<<(char)124<<'\n';
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)47<<(char)32<<(char)47;
    cout<<(char)124<<(char)32<<(char)124;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)124<<(char)95<<(char)124;
    cout<<(char)32<<(char)32<<(char)124;
    cout<<(char)32<<(char)124<<'\n';
    cout<<(char)32<<(char)32<<(char)47;
    cout<<(char)32<<(char)47<<(char)32;
    cout<<(char)124<<(char)49<<(char)124;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<(char)47;
    cout<<(char)50<<(char)124<<'\n';
    cout<<(char)32<<(char)47<<(char)32;
    cout<<(char)47<<(char)32<<(char)32;
    cout<<(char)124<<(char)57<<(char)124;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)84<<(char)79<<(char)32;
    cout<<(char)32<<(char)47<<(char)48;
    cout<<(char)47<<(char)32<<'\n';
    cout<<(char)47<<(char)32<<(char)47;
    cout<<(char)95<<(char)95<<(char)95;
    cout<<(char)124<<(char)53<<(char)124;
    cout<<(char)95<<(char)95<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)47<<(char)48<<(char)47;
    cout<<(char)32<<(char)32<<'\n';
    cout<<(char)124<<(char)95<<(char)95;
    cout<<(char)95<<(char)95<<(char)95;
    cout<<(char)124<<(char)50<<(char)124;
    cout<<(char)95<<(char)95<<(char)124;
    cout<<(char)32<<(char)32<<(char)47;
    cout<<(char)49<<(char)47<<(char)32;
    cout<<(char)32<<(char)32<<'\n';
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)124<<(char)32<<(char)124;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)47<<(char)32;
    cout<<(char)47<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<'\n';
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)124<<(char)32<<(char)124;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)47<<(char)32<<(char)47;
    cout<<(char)95<<(char)95<<(char)95;
    cout<<(char)95<<(char)32<<'\n';
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)32<<(char)32<<(char)32;
    cout<<(char)124<<(char)95<<(char)124;
    cout<<(char)32<<(char)32<<(char)124;
    cout<<(char)95<<(char)95<<(char)95;
    cout<<(char)95<<(char)95<<(char)95;
    cout<<(char)95<<(char)124<<'\n';
    getch();
    return 0;
}  

salida

ingrese la descripción de la imagen aquí


Salida: 1> c: \ users \ 1 y 2 es 3 \ documents \ visual studio 2012 \ projects \ consoleapplication1 \ consoleapplication1 \ consoleapplication1.cpp (87): error C4996: 'getch': el nombre POSIX para este elemento está en desuso. En su lugar, use el nombre conforme ISO C ++: _getch. Consulte la ayuda en línea para obtener detalles.
Hosch250

Genial, una vez que lo arreglé.
Hosch250

@ user2509848 ¿cuál fue el error?
Mukul Kumar

Lo publiqué en el primer comentario. Visual Studio quería getchser _getchen su lugar.
Hosch250

12

JavaScript

window.location = "https://www.google.nl/search?q=the+answer+to+life+the+universe+and+everything";

Salidas 42.


12

J

Una línea simétrica sin caracteres alfanuméricos.

   _<.>.>_ (=(+^:]) ~=(-*-)=~ ([:^+)=) _<.<.>_

Salidas 42.

El cálculo principal es:

techo (1 + (1 - e ^ 2) ^ 2) = 42


11

JavaScript

El código ASCII para *, que para la mayoría de los programadores significa "todo", es 42. se +!"The End of the Universe"evalúa a 0.

String.prototype.answer = function() { alert(this.charCodeAt(+!"The End of the Universe")); };
'*'.answer();

2
Prefiero pensar en ello como una estrella de Kleene .
primo

También podrías escribir"The End of the Universe"|0
cepillo de dientes

10

PHP

Pregúntale a WolframAlpha. Aquí hay un código que usa la API WolframAlpha para recuperar el resultado de una consulta de búsqueda específica:

<?php

$searchTerm = "What's the answer to life, universe and everything?";

$url = 'http://api.wolframalpha.com/v2/query?appid=APLTT9-9WG78GYE65&input='.urlencode($searchTerm);
$xml = file_get_contents($url);

$xmlObj = simplexml_load_string($xml);
$plaintext = $xmlObj->xpath('//plaintext')[1];
$answer = preg_replace('/\D/', '', $plaintext);

echo $answer;

Salida:

42

Demostración de trabajo


1
Ir a la red cuando realmente no lo necesita no me parece muy creativo, especialmente porque es un antipatrón común.
Blacklight Shining
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.