Maneira mais criativa de exibir 42


386

Douglas Adams nasceu em 11 de março de 1952 e morreu quando tinha apenas 49 anos. Em homenagem a esse escritor maravilhoso, eu desafio você a exibir 42 da maneira mais criativa possível.

Você pode imprimi-lo no log, através de algum método complicado, ou exibi-lo como arte ASCII, ou qualquer outra coisa! Basta criar um método criativo de exibir 42.

Por ser um concurso de popularidade, qualquer que seja a resposta mais positiva até 11 de março, será declarada vencedora.

Nota: isto não é uma duplicata. A pergunta que foi marcada como duplicada foi uma pergunta de controle de código cujo objetivo era escrever o código na saída 42, não encontrar a maneira mais criativa de exibi- lo.

Vencedor: grovesNL! Com impressionantes 813 votos! Parabéns!

Menções Honrosas:

Mr Lister C 228 Pelo uso inteligente de #define

David Carraher Mathematica 45 Para que a função matemática complicada e complicada atinja 42

Calculadora Aschratt do Windows 20 Porque, bem, é calculadora do Windows E definitivamente 1337.

f.rodrigues Python 17 Devido ao uso inteligente do uso de programas externos. E MSPaint

Jason C LMGTFY 14 Para o uso de LMGTFY (Deixe-me pesquisar no Google por você)

Trimsty Python 12 Para o uso inteligente de uma mensagem de erro na saída 42.

Mukul Kumar C ++ 7 Para a boa saída ASCII.

Se você acha que há outra resposta que vale a pena colocar na lista, por favor, comente!


6
A velha pergunta encerrada era um trolling de código, ou seja, qualquer coisa que não mostra 42 além de parecer fazê-lo ou fazê-lo de uma maneira realmente horrível. Este não é um trolling de código, ou seja, a saída deve realmente ser 42 de uma maneira agradável. Portanto, não é duplicado.
Victor Stafusa 23/02

2
@DanDascalescu Este site do SE tem muitas perguntas sem requisitos rígidos, o que permite aos usuários exercer liberdade criativa em suas respostas. Às vezes, muitas restrições podem impedir a expressão da criatividade
grovesNL

9
A questão deve permanecer em 42 votos.
Zero Fiber

28
Marvin, o robô "Eu postaria minha resposta brilhante, mas você provavelmente recusaria. Estar certo o tempo todo é tão deprimente."
Reactgular

3
Podemos obter 42 favoritos?
Milo

Respostas:


843

Brainfuck duplo

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

que gera ...

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

que gera ...

6*7=42

92
Eu sempre pensei que algo estava fundamentalmente errado com o universo.
Mfitzp

147
Deveria ser 6*9=42.
Proxy

17
@Proxy: É verdade, mas às vezes essas referências são perdidas sobre os espectadores, mesmo apesar do contexto ... ;-)
grovesNL

19
@IsmaelMiguel: Isso é tão base 10 de você ...
Dennis

26
Votou a questão toda para que as pessoas vissem essa resposta.
Michael Stern

329

C

Aqui está um oldie, mas goodie ...

#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 contém 42 caracteres ASCII diferentes.


15
isso é incrível
ASKASK

41
Adoro o uso de #define para acertar as contas ^ ^. Você é um idiota.
Olivier Dulac

35
@mikhailcazi: O pré-processador substituirá essas constantes literalmente, six*ninetornando - se 1+5*8+1qual é 42. Muito bem, Sr. Lister.
bodo

7
@canaaerus Puta merda, isso é genial. Bravo, Sr. Lister!
Mikhailcazi

4
@mikhailcazi #definetrabalha em C ++ exatamente da mesma maneira que em C. #
Lister

137

Brainfuck

Demorou um pouco para chegar lá, mas eu gosto do resultado:

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

Quando executado, ele imprimirá 42, é claro.


6
Nem mesmo vou tentar (bater ou entender) ... Isso me lembra muitas entradas que eu vi no Concurso Internacional de Código C Ofuscado.
Isiah Meadows

64
Eu tenho que admitir, o estilo de fonte do código para mostrar "42" é lindo ...
Wally West

15
Eu gostaria que eles escrevessem o kernel do Linux em brainfuck.
23414 devnull

10
Infelizmente, você foi superado pelo grovesNL .
Blacklight Shining

6
Concordo. A fonte deles não parece tão boa quanto a minha, mas a saída aninhada é uma ideia muito legal. Também o código deles faz mais sentido que o meu. Primeiro projetei a fonte como arte ascii e depois brinquei com o código para ajustá-la à contagem de 220 caracteres da arte ascii, para que meu código contenha muitas coisas inúteis.
Donarsson 23/02

133

JavaScript:

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

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

A saída é:

42.

Nada mal, né? :)

Para as pessoas que não entendem, ele realmente avalia o seguinte:

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


17
Sido codificação JavaScript por anos, mas não tenho idéia o que é facepalm
Songo

5
@CarlWitthoft Como funciona é que _é um nome de variável válido em JavaScript - e assim é __, ___, ____, ________.
Escova de dentes

3
Muito Obrigado. Vou arquivar essas informações (perigosas :-)) para uso futuro.
Carl Witthoft 24/02

2
Quem disse que os programadores não são criativos!
24414 Jonathan

1
Como alguém que escreve muito JavaScript diariamente ... bem feito, você realmente me surpreendeu por um tempo. Eu felizmente passaria por ela e assumi algum esolang.
George Reith

76

C, Doze Dias de Estilo Natal

Nova versão:

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);}

Resultado:

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

A propósito, também verifique minha resposta de conversão de texto em fala .


Versão 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(_);}

A saída é:

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

Espaçamento alternativo, se você estiver se sentindo brega:

        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(_);}

O programa é uma única declaração recursiva. Eu fiz isso no estilo do meu programa C ofuscado favorito de todos os tempos, Doze Dias de Natal (compile, prepare a mente para ser soprado, corra).


COMO

Além disso, como esse parece um lugar tão bom quanto qualquer outro, aqui está um guia que descreve como criar esse tipo de programa. Este guia usa a versão original acima como exemplo. Além do primeiro bit com as letras maiúsculas, são etapas gerais:

INICIAL: Primeiramente, comecei escrevendo as letras maiúsculas:

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

Em seguida, fiz uma lista numerada dos padrões exclusivos em cada linha de caracteres de 5 colunas:

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

E assim, cada uma das 5 linhas de pixel de texto se torna uma série 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 ofuscação (e facilidade de programação), adicionamos o caractere '#' aos números. No programa abaixo, patternsestá a matriz de padrões de pixel e linesa matriz ofuscada de códigos de padrão para cada linha, terminada por um 'x'. Para ofuscação adicional, definimos pixels "ativados" patternscomo qualquer caractere que não seja um espaço; isso nos permite colocar mais texto enganoso em 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;
  }
}

PASSO 1: O próximo passo envolve algumas tarefas:

  • Remova todos os loops e use recursão.
  • Altere todas as funções (exceto principal) para o formulário int function (int, int)e use os mesmos nomes de parâmetro para cada uma. As razões ficarão claras mais tarde.
  • Mude mainpara o formulário int main (int, int, int)e nomeie os dois últimos parâmetros iguais aos nomes dos parâmetros de função.
  • Substitua todas as referências a constantes de string pelas próprias; e use cada sequência apenas uma vez, se possível.
  • A inclusão pode ser removida; é desnecessário para int putchar (int).

Também podemos tirar proveito do estranho recurso C, onde a[b]é equivalente b[a]a ofuscar ainda mais.

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);
}

PASSO 2: Em seguida, use os operadores ?:e ,para transformar cada função em uma única returninstrução. Estou ilustrando isso separadamente do acima, porque é aqui que as coisas começam a ficar confusas de se olhar. Lembre-se de que putchar()retorna um inte ?:tem precedência 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);
}

PASSO 3: Ok. O próximo passo é grande. Todas as funções agora são uma única instrução da mesma forma. Agora podemos combiná-los todos em uma única função, identificando cada um por um número - essencialmente transformando todo o programa em uma única função recursiva. Observe que o primeiro parâmetro a mainserá 1 quando o programa for executado sem argumentos, portanto esse deve ser o nosso estado inicial.

Além disso, como nosso parâmetro cto mainé nossa variável de estado, sempre sabemos seu valor e podemos ofuscar um pouco mais substituindo constantes inteiras pelos valores em termos de c(por exemplo, quando sabemos que cé 2, podemos substituir 5 com c+3). Outras pequenas ofuscações também podem ser feitas (por exemplo, substituí '#'por 35e 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));
  }
}

PASSO 4: Finalmente, remova o switchbloco usando uma série de ?:operadores. Também podemos remover as intdeclarações, pois C as usará por padrão, assim como as returnpróprias (o que gerará um aviso na pior das hipóteses). Depois disso, nosso programa é uma função única e recursiva com uma instrução. Muito legal, né?

Editar: Substituí putchar()por um maine c==4abaixo; porque eu pensei no último minuto:

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(_);
}

Se você quiser adicionar um pouco de talento, você pode usar os números mais interessantes para ce até mesmo basear as verificações off de outros números (por exemplo, para o c==2caso, zé ignorado e disponível, então em vez de chamar main(2,z,_)você poderia chamar main(-97,_,_)e substituir c==2com c<-z). Seja criativo; as possibilidades são infinitas.

ACABAMENTO: O passo final, então, é organizar o texto em algum padrão criativo, e pronto! Você pode ajustar um pouco o código para ajudar na formatação (por exemplo, adicionei alguns dados extras no final da patternsstring no programa publicado para ajudar a ajustar o comprimento da linha). As senhoras certamente estarão prontas.


Devo remover o guia? Eu meio que gosto do mistério sem ele.
Jason C

Atualizei a resposta com uma nova versão mais curta e imprime as letras na saída. O guia é baseado na versão original (ainda presente). A nova versão armazena a saída como dados RLE; a primeira cadeia longa são os dados.
Jason C

2
Eu quero marcar essa resposta com +1, desde que você tenha explicado o "porquê" da sua solução, mas atualmente ela está em 42 repetições e não quero estragar isso. ;)
Adam Parkin

4
@AdamParkin Haha! Bem, aqui, se chegar a 43, é seu trabalho diminuir o voto.
Jason C #


63

Java

(ou C ++, o código é quase semelhante)
Usando as funções String, não esqueça de incluir sua biblioteca!

PS: Eu sei que é demorado, mas deveria ser criativo, certo? E de qualquer maneira, não é um "menor ganho de bytes".

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);

Aqui está a saída:

         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 

Imagine minha miséria quando contei e descobri que "O restaurante no fim do universo" tinha 41 caracteres! : / Suspiro.


2
por que existe um 'DA' na saída? é intencional?
Mhmd

14
@ user689 D ouglas A dams :)
mikhailcazi

9
Na verdade, 41 também é DA de certa forma (D é a quarta letra, A é a primeira). Anime-se!
23414 vadchen

11
4-1 = 3, o que significa: • _ •) (• _ •)> ⌐ ■ - ■ (⌐ ■ _ ■) Half Life 3 confirmado.
Mohd Abdul Mujib 23/02

17
O restaurante no fim do universo tem 41 caracteres + "\ 0": DDD
enterx 23/02

59

Mathematica

Take 1

Com algum trabalho, eu devo ser capaz de jogar isso um pouco. :)

Em 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]]

Em TraditionalForm:

quarenta e dois

Testando:

answer[ultimateQuestion[Life,theUniverse,Everything]] 

42.


Take 2

Nota: Os numerais foram feitos da seguinte maneira.

  • "42" foi impresso pela primeira vez na tela em uma fonte muito grande, com os eixos exibidos, para que as coordenadas dos pontos principais pudessem ser identificadas.
  • Outro "4" foi desenhado com uma ampla linha reta, conectando os respectivos pontos-chave. Foi sobreposto ao "4" desenhado anteriormente para verificar a precisão. O "2" foi desenhado como uma curva BSpline. Alguns dos pontos-chave, que agora eram pontos de controle, tiveram que ser colocados em posição por tentativa e erro para obter as curvas desejadas.
  • Uma terceira coordenada (sempre zero) foi adicionada à linha e ao BSplineCurve para ativar a exibição em 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]] ]

pegue 2


1
Felizmente não é uma questão de golfe :) parece ser uma boa dose de criatividade matemática lá ...
cormullion

1
Obrigado. O Mathematica certamente oferece muitas opções para explorar.
DavidC 23/02

3
Agradável; gostaria de poder voltar no tempo e colocar esse gráfico em geocities.com/42, haha.
Jason C

57

Parece apropriado:

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 ' '

Resultado:

4
2

Ubuntu 12.04, área de trabalho de 64 bits


23
+1 para não entre em pânico
Milo

Seria um basismo, mas echo $(grep -i ... tr -d ' ') | sed 's/ //g'colocaria tudo em uma linha. Você também pode usar aspas em vez do $()formulário, mas é mais difícil colocar um comentário aqui.
MikeFeltro Renfro


@MikeRenfro Como isso é um bashishm? $()é especificado pelo padrão POSIX .
precisa saber é o seguinte

Correto, estou obviamente desatualizado. A última vez que verifiquei (há muitos anos), pensei que era. Pode ter sido errado também.
9135 Mike Renfro #

45

Calculadora do Windows

Multiplicando Pi por 13,37 e ignorando o decimal:P

Quarenta e dois


17
1 porque fracções são definitivamente não 1337.
Jason C

1
Calculadora de um programador teria sido melhor, mas que a calculadora não tem (torta)
Mukul Kumar

1
1337 * math.pi / 100
cromano

11
round (1337 * math.pi / 100) <- Uma pequena alteração desde que o pie é redondo.
Kevin

41

Pitão

Eu acho que só funciona no 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])

O resultado é abrir o Paint e pintar 42 como mão livre.

42.


1
Eu não tenho win32api :( Queria ver isso ... Ainda +1: D
Timtech 26/02/14

Eu não uso o Windows, então não posso executá-lo; mas seu caminho é brilhante .
pushpen.paul

3
Eu queria dar um voto positivo, mas isso tem exatamente 42 votos positivos, não quero estragar tudo.
Rohcana 5/09/2015

39

Java (Swing)

Isso exibirá um quadro desenhando a resposta . Ele usa apenas 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 o bloco "Acabei de gastar uma tonelada de tempo para formatar este e realmente não sinto vontade de trabalhar as sobras" na parte inferior, haha
Jason C

3
@JasonC Isso é exatamente o que eu pensei! ; D Amanhã, trabalharei em um programa que formata código para arte ASCII e ficarei rico!
bobbel

Comecei a fazer isso com o meu e desisti rapidamente. Bom trabalho.
ChiefTwoPencils

28

Mathematica

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

42.

embora eu ache que é trapaça, na verdade, já que é codificado. E não muito criativo, da minha parte ... :)


28

Rubi

É sabido o que você ganha se multiplicar seis por nove . Isso fornece uma solução:

puts (6 * 9).to_s(13)

Pitão

Uma variante da 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)))

Resultado:

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

2
Infelizmente, como o seu link da Wikipedia indica, o DNA rejeita o primeiro método de produção de 42: "Posso ser um caso lamentável, mas não escrevo piadas na base 13."
precisa saber é o seguinte

26

Javascript

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

3
Outro que me deu um momento na WTF até eu perceber true == 1.
George Reith

12
ALERTA! CATERPILLARES ASCII ESTRANHOS! USE CUIDADO EXTREMO!
Jason C

Use em []vez de ""( [] == '')! alert((!![]+-~[])*(!![]+-~[])+[]+(!![]+-~[]))
Escova de dentes

(!-[] === true) && (!~[] === false). Você também pode substituir {}para [].
Escova de dentes

1
Que tal (!!{}+!-[]<<-~{})+[]+(!-[]+-~[])?
Escova de dentes


23

Adiante:

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 LOAD produz:

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


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

Resultado:

42.


2
+1 por empregar uma equação linear interessante, bom trabalho!
recursion.ninja

17

SWI-Prolog, alguém?

?- X.

Resultado:

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

Isso é ainda mais preguiçoso do que o chamado Mathematica-Wolfram-Alpha, mas ei!


3
Bem-vindo ao Code-Golf! Não se esqueça de adicionar uma explicação sobre por que essa resposta é criativa!
24714 Justin

3
@Quincunx É um ovo de páscoa no SWI-Prolog.
svick 24/02

15

Shell Linux

Aqui está algo que eu escrevi em 1999 e usei como minha assinatura Usenet na época.

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

Editar: Ha! Essa foi a 42ª resposta.


15

Versão do 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 */

Versão 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 */

Resultado:

 42

2
Eu nunca vou entender como qualquer humano são pode escrever uma data nesta ordem. O fato de você ter que colocar um comentário lá prova o quão inútil é esse formato.
24414

1
@canaaerus Acabei de usar a data em um formato específico para que possa ser processada por um programa para chegar 42. Tentei várias outras maneiras legíveis por humanos, e foi o mais próximo que pude transformar a data para chegar à solução.
palerdot

24
@canaaerus Eu nunca vou entender como os americanos também podem escrever datas mm/dd/yy. Se você diz 04/03/11, eu o leria em 4 de março de 2011 - e não em 3 de abril.
Escova de dentes

7
@palerdot. Até onde eu sei, apenas americanos e americanos (e ocasionalmente canadenses) escrevem datas dessa maneira estranha, confusa e "do meio-termo".
TRiG

2
@TRiG: O que você espera? Além de nós nas áreas de ciência e engenharia, evitamos o sistema métrico mais intuitivo e lógico.
ChiefTwoPencils

15

dc

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

Tentando multiplicar 1+8e 5+1obter 42. Parece que a ignorância da precedência do operador levou a 42.


Pitão

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

Resultado: 42


bater

(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"));}

Resultado: 42

  • Você notou o uso de caracteres de backspace?
  • Você sabe o que isso resulta?

Não .. por favor, explique!
Antonio Ragagnin 23/02

Os caracteres de backspace ocupam a cadeia com um comprimento de 42 bytes. Portanto, o primeiro fopen é usado para abrir o dispositivo nulo para acesso de gravação. Em seguida, fprintf grava 42 bytes em null, retornando o número de bytes gravados. Finalmente, 42 é formatado pela string de formato "% d" da função printf para exibir 42. Gostei!
CasaDeRobison 24/02

12

Brainf ** k

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

Isso depende de um estouro no intérprete?
Cruncher

Sim, parece que ele assume um estouro para 255. 255/5 = 51 + 1 = 52, que é o código de caractere para 4. Eu não acho que todos os intérpretes fazem isso, mas +1
Cruncher

@Cruncher Precisa de células de empacotamento de 8 bits. Este é o tipo mais comum.
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;
}  

resultado

insira a descrição da imagem aqui


Saída: 1> c: \ users \ 1 e 2 é 3 \ documents \ visual studio 2012 \ projects \ consoleapplication1 \ consoleapplication1 \ consoleapplication1.cpp (87): erro C4996: 'getch': o nome POSIX deste item está obsoleto. Em vez disso, use o nome de conformidade com o ISO C ++: _getch. Consulte a ajuda online para obter detalhes.
Hosch250

Legal, uma vez que eu consertei.
Hosch250

@ user2509848 qual foi o erro?
Mukul Kumar 24/02

Postado no primeiro comentário. O Visual Studio queria getchestar _getchem seu lugar.
Hosch250

12

Javascript

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

Saídas 42.


12

J

Linha única simétrica sem caracteres alfanuméricos.

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

Saídas 42.

O cálculo principal é:

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


11

Javascript

O código ASCII para *, que para a maioria dos programadores significa "tudo", é 42. é +!"The End of the Universe"avaliado como 0.

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

2
Prefiro pensar nisso como uma estrela Kleene .
primo

Você também pode escrever"The End of the Universe"|0
Toothbrush

10

PHP

Pergunte a WolframAlpha. Aqui está um código que usa a API WolframAlpha para recuperar o resultado de uma consulta de pesquisa 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;

Resultado:

42

Demonstração de trabalho


1
Ir à rede quando você realmente não precisa não me parece muito criativo, especialmente porque é um antipadrão comum.
Blacklight Shining
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.