Como grande fã da série de TV Lost , sempre me intrigava com a sequência de números que aparece repetidamente nos episódios. Esses números são:

$4, 8, 15, 16, 23, 42$ (A104101)

Usando qualquer linguagem de programação, escreva um código que produz esses números.

Pontuação:

• Menor resposta ganha

• A saída não deve conter outros números ou letras. Você pode usar qualquer outro caractere como separador, ou mesmo nenhum separador.

• Você não pode separar dígitos do mesmo número. $48\_15162342$ é uma resposta válida, mas $481\_5162342$ não é.

• Você deve respeitar o pedido.

• Se o seu código não contiver nenhum número da sequência, reduza sua pontuação em 30%. Esta regra permite que você insira os dígitos separadamente. Por exemplo:

  abcde1fg5h
  

  É um candidato válido porque a resposta não contém o número $15$ , apenas seus dígitos. No entanto, qualquer $4$ ou $8$ invalidará o bônus.

• Se o código não contiver nenhum dígito, reduza sua pontuação em 50%. Outros personagens como , ou ainda são válidos para esse bônus.$¹$$²$$³$

Perdido , 29 27/2 = 13,5 bytes

%?\>>>>>>>>>>
>>\"*"@"

Experimente online! ou verifique se é determinístico

Parecia o idioma certo para usar.

Explicação:

Lost é uma linguagem 2D onde o ponteiro começa em qualquer lugar , indo em qualquer direção. Isso geralmente leva a muita verificação dupla de que o ponteiro não entrou em uma seção cedo.

...>>>>>>>>>>  These arrows filter all pointers that appear on the top line
.............  Or going vertically


%............  This flips the flag so that the program can end
.............  This stops premature termination

.?\..........  Clear the stack by skipping if a value popped from the stack is positive
.............  When the stack is empty, the \ directs the pointer down

.............  The \ directs the pointer right
..\"*"..  The string literal pushes all the Lost values to the stack

..\..........  The @ terminates the program if the % flag is switched
>>\........@.  Otherwise it clears the stack and repeats

.............  The quote here is to prevent the pointer getting stuck
............"  This happens when the pointer starts between the other quotes

Geléia , 7/2 = 3,5 bytes

“ƲÞIȥ’Ḥ

Imprime os números sem separador, ou seja, o número inteiro $4815162342$ .

Experimente online!

Como funciona

“ƲÞIȥ’é literal inteiro bijetivo base-250.
Ʋ, Þ, I, E ȥter (1-based) índices $154$ , $21$ , $74$ , e $171$ na página de código de Jelly, para que eles codificam o número inteiro $250^3\cdot154+250^2\cdot21+250\cdot74+171=2407581171$ .

Finalmente, Ḥ(unhalve) duplica o número inteiro, dando origem a $2\cdot2407581171=4815162342$ .

É necessário dobrar, porque a codificação da saída leva diretamente a “¡9)Ƙ[’, que contém um dígito.

Neim , 6 5 bytes, 3 2,5 pontos

Jσς§A

Explicação:

J     Push 48
 σ    Push 15
  ς   Push 16
   §  Push 23
    A Push 42
      Implicitly join the contents 
      of the stack together and print

Experimente online!

05AB1E , pontuação: 10 9 7 bytes / 2 = 3,5

•‘o]Ê•·

Experimente online.

Ou alternativa de 7 bytes :

•’µ[%•R

Experimente online.

Ambos emitindo o número inteiro 4815162342 .

Explicação:

•‘o]Ê•     # Compressed integer 2407581171
      ·    # Doubled

•’µ[%•     # Compressed integer 2432615184
      R    # Reversed

Veja esta minha dica 05AB1E (seção Como comprimir números inteiros grandes? ) Para entender por que •‘o]Ê•é 2407581171e •’µ[%•é 2432615184.

Resposta antiga de 9 bytes que gera a lista [4,8,15,16,23,42]:

•ΓƒÇ²•т;в

-1 byte (e, portanto, pontuação -0,5) graças a @Emigna .

Mais longo que a outra resposta 05AB1E , mas isso gera a lista em [4,8,15,16,23,42]vez do número inteiro 4815162342.

Experimente online.

Explicação:

•ΓƒÇ²•       # Compressed integer 1301916192
      т;     # Integer 50 (100 halved)
        в    # Convert the first integer to Base-50 (arbitrary): [4,8,15,16,23,42]

Consulte esta dica 05AB1E (seções Como compactar números inteiros grandes? E Como compactar listas inteiras? ) Para entender por que •ΓƒÇ²•é 1301916192e •ΓƒÇ²•50вé [4,8,15,16,23,42].

JavaScript (ES7), 34/2 = 17 bytes

_=>eval(atob`NjUwNTgxMDErNDEqKjY`)

Experimente online!

Isso decodifica e avalia a expressão "65058101+41**6", que não contém nenhum dígito uma vez codificado na base-64.

JavaScript (ES6), 13 bytes

Solução óbvia chata.

_=>4815162342

Experimente online!

Python 3 , 25 bytes, 12,5 pontos

print(*map(ord,'ዏٗ*'))

Experimente online!

） （髒, ⿰ 馬 葬）, 𧨦 （謚, ⿰ 言 ⿱⿵ 八一 皿 custam 4 bytes, mas U + 0657 custam apenas 2 bytes ...

Python 3 , 29 bytes, 14,5 pontos

print(ord('𩦦')*ord('湡'))

Experimente online!

𩦦 （⿰ 馬 葬） é o caractere variante de 髒, que significa "sujo". 湡 é o nome de um rio. E eles não são nada relacionados a esta questão, como eu sabia.

Brain-Flak , 52/2 == 26 bytes

(((((((((()()()())){})){}[()])())[]()()())){}[[]]())

Experimente online!

Java 8, pontuação: 12 11.9 (70% de 17 bytes)

v->767*6277917L+3

-0,1 pontos graças a @RickHitchcock .

Experimente online.

Explicação:

v->               // Method with empty unused parameter and long return-type
  767             //  767
     *6277917L    //  multiplied by 6277917 (as long)
              +3  //  And then 3 is added

Resposta antiga com uma pontuação de: 12 (50% de 24 bytes):

v->(long)''*'Ⓥ'*'䧶'

Contém um caractere não imprimível 0x1B.

Experimente online.

Explicação:

v->                   // Method with empty unused parameter and long return-type
  (long)              //  Cast the character (and therefore the result) to a long
        ''            //  27
           *'Ⓥ'       //  Multiplied by 9419
                *'䧶'  //  Multiplied by 18934

Em Java, os caracteres podem ser autoboxados para números inteiros que mantêm seu valor unicode. Infelizmente, o unicode máximo suportado para caracteres é 65,535, portanto, não posso usar apenas dois caracteres para multiplicar (já que os dois maiores números que dividem o esperado 4,815,162,342são 56,802e 84,771, onde 84,771infelizmente excede o máximo 65,535.
Além disso, como o tamanho máximo de um inté 32 ² -1 ( 2,147,483,647) e o resultado 4,815,162,342é maior que isso, uma conversão explícita para long, que pode conter até 64 ² -1 ( 9,223,372,036,854,775,807), é necessária.

Resposta chata teria sido 14 bytes sem nenhum bônus:

v->4815162341L

Experimente online.

R, 18x0,7 = 12,6 pontos

cat(9*2*267509019)

Bastante auto-explicativo, apenas faz alguma aritmética evitando os números em questão.

7 , 10 bytes, 27 caracteres

115160723426754314105574033

Experimente online!

A representação empacotada deste programa no disco é ( xxdformato):

00000000: 269c 3a71 6f63 308b 7c0d                 &.:qoc0.|.

Explicação

Já vimos essa sequência de números antes, em Automatize Saving the World , que tratava de imprimir os números em intervalos regulares, tornando-o interessante ao exigir o uso de um idioma muito antigo. Muitos idiomas mais novos podem ter suas próprias reviravoltas que tornam esse desafio interessante. _{(Sim, este parágrafo e, de fato, a razão pela qual comecei a escrever esta resposta, é efetivamente apenas uma maneira de fazer com que todos os desafios relacionados apareçam juntos na barra lateral; normalmente as pessoas fazem isso usando comentários, mas eu não tenho representantes suficientes. .)}

A primeira coisa a observar é que 7 é feito inteiramente de dígitos, portanto, é improvável que os bônus aqui funcionem (embora se você visualizar o programa como uma sequência de octetos, nenhum deles corresponda às representações ASCII de qualquer um dos números originais , para que você possa reivindicar o bônus nesse sentido). A próxima coisa a ser observada é que 7 possui comandos para recriar a sequência de comandos que provavelmente produziu um dado específico; então poderíamos interpretar os números perdidos4815162342 como uma seção do próprio programa 7?

A resposta é "não exatamente". A parte mais problemática é esse segundo número,8 ,. 7 programas são escritos em octal; não existe um número igual a 8. Portanto, o início da string terá que ser impresso de maneira diferente.

A base do programa é, portanto, baseada no programa 7 "Hello world":

5431410557403
543141055          string literal
         7         separate data from code
          4        rearrange stack: {program's source}, empty element, {literal}
           0       escape {the literal}, appending it to {the empty element}
            3      output {the escaped literal}, pop {the program's source}

com o literal escapado em um idioma específico do domínio, interpretado da seguinte maneira:

5                  output format: US-TTY using pairs of digits in the string
 43                select character set: digits and common symbols
   14              "4"
     10            "8"
       55          forget the set output format

Depois disso, vem um extra 3, que gera o elemento restante da pilha (e sai devido à pilha restante insuficiente). Esse elemento é especificado no início do programa e, para evitar o incomparável 6(que funciona um pouco como um colchete de fechamento), nós o geramos usando código, em vez de gravá-lo diretamente como dados. (Observe que existem dois 7caracteres implícitos no início do programa, o que é relevante aqui):

{77}115160723426
 7                 empty stack element
  7 11516          append "1151"
         0         append "6"
          723246   append "2324"

Isso produz o seguinte literal:

115162324
1                  set output format: literally as octal
 15162324          "15162324"

que é impresso.

05AB1E , 6 * 0,7 = 4,2 bytes

•1Z&ð“

Experimente online!

Imprime o número não compactado da base-255

Origem do conjunto MASM 8088, (93 bytes - 50%) = 46,5 bytes

Não usando números ou a sequência na fonte:

MOV AH,'P'-'G'
LEA DX,L
INT '!'
RET
T EQU '-'-'+'
L DW 'ph'/T,'jb'/T,'lb'/T,'fd'/T,'dh'/T,'$'

Resultado:

A>LOST.COM
4815162342

Carvão vegetal , 13 bytes / 2 = 6,5

ＩＥTPIHA.⁻⁸⁸℅ι

Experimente online! Link é a versão detalhada do código. Funciona subtraindo os códigos ASCII da string TPIHA.de 88 e convertendo em string.

Aheui (esótopo) , 45 bytes (15 caracteres) * 0,5 = 22,5 pontos

반밤밪박밭빠따받발따밣뱣히망어

Experimente online!

Explicação:

Veja isto também; Aheui Referência ( Inglês )

Aheui program starts with default stack '아'(or none)

반: push 2, move cursor right by 1(→).
밤: push 4, →
밪: push 3, →
박: push 2, →
밭: push 4, →
빠: dup, →
따: pop 2, push mul result(16).
받: push 3, →
발: push 5, →
따: pop 2, push mul result(15).
밣: push 8, →
뱣: push 4, move cursor right by 2(→→).
히: end.
망: pop 1, print, → (if stack is empty, move cursor left by 1.)
어: move cursor left by 1(←).

Observe que ㅁ (instrução de impressão) move o cursor na direção inversa se a pilha (ou fila) estiver vazia.

Perl 5 , 16 bytes - 30% = 11,2

say 0x5FAB2EA2*3

Experimente online!

PowerShell , 12 bytes * 0,7 = 8,4

0x5FAB2EA2*3

Experimente online!

"Porta" da resposta de Xcali para obter uma resposta melhor do PowerShell.

JavaScript, 143 bytes (não sabe como pontuar)

(g=`${2*2}`)=>g.repeat(6).replace(/(.)/g,(m,p,i,k='')=>
  (k=m*[g-3,g-2,g,g,+g+2,g*3-1][i]
  ,RegExp(`${g-2}|${g}`).test(i)?k-1:i==+g+1?k-(g/2):k))

Experimente online!

Comece com seis 4, multiplique, adicione, subtraia por, de, 4para derivar a saída.

PHP, 35/2 = 17,5

<?=zzzzzzzzzzzzzzz^NVBVKOVKLVHIVNH;

uma abordagem digital: 40 * .7 = 28

<?=2+2,_,5+3,_,17-2,_,17-1,_,17+6,_,7*6;

sem dígitos, sem strings: 68/2 = 34

<?=$p++,!$p++,$p+=$p,_,$p+=$p,_,~-$q=$p+$p,_,$q,_,--$p+$q,_,$p*~-$p;

Experimente online .

JavaScript (SpiderMonkey), 67 bytes / 2 = 33,5 60 bytes / 2 = 30 58 bytes / 2 = 29 48 bytes / 2 = 24

-7 bytes / 3,5 , -2 bytes / 1 cortesia de @JoKing, -10 bytes / 5 cortesia de @tsh

print(a=-~-~-~-~[],a+=a,b=a+~-a,a+a,a+b,--b+b+b)

Experimente online!

APL (Dyalog Unicode), 18/2 = 9 bytes

×/⎕UCS'𩦦湡'

Apenas entediante multiplicação de caracteres antigos.

Experimente online!

JavaScript (ES6), 16 * 0,7 = 11,2 bytes

_=>767*6277917+3

Produz os dígitos sem delimitadores.

Experimente Online!

Espaço em branco , pontuação: 49 41 bytes / 2 = 20,5

[S S S T    S S S T T   T   T   T   S S S S S S S T T   S S S T S T T   T   T   T   S S T   T   S N
_Push_4815162342][T N
S T _Print_number]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Pseudo-código:

Integer i = 4815162342
Print i as number to STDOUT

Explicação:

Em espaço em branco, um número é enviado da seguinte maneira:

• S: Ativar manipulação de pilha
• S: Número de envio
• S/T : Positivo / negativo, respectivamente
• Alguns T/ Sseguidos por um único N: decimal como binário, onde Té 1 eS é 0

Depois disso, é simplesmente impresso com TNST:

• TN: Ativar E / S
• S: Saída na parte superior da pilha
• T: Como número

F #, 45 bytes = 22,5 pontos

Apenas um forloop comum que imprime os dígitos:

for c in"DHOPWj"do printf"%d"(int c-int '@')

O acima é um programa completo que pode ser compilado em um executável.

Em um REPL (loop de leitura e avaliação), por exemplo, FSI (F # Interactive), a seguinte versão mais curta funcionará, pois o REPL emitirá uma representação da expressão avaliada; tem 35 bytes = 17,5 pontos:

[for c in"DHOPWj"->int c-int '@'];;

Pyke , 3 pontos

77 91 f8 86 98 06

Experimente aqui!

O primeiro byte sinaliza para ler na base 128 até que um byte sem o bit alto seja definido.

Finalmente, 32 é subtraído do resultado (por razões históricas).

Isso permite a geração de grandes números em quantidades muito pequenas de espaço

MathGolf , 7 bytes * 0,5 = 3,5

ÿ≤┼ÇÅ$∞

Experimente online!

Explicação

Observe que esse código ainda não funciona no TIO. Fiz algumas alterações recentemente no MathGolf, incluindo a adição do $operador. Depois que ele for puxado para o TIO, você poderá executá-lo lá, então farei uma atualização para esta resposta. Funciona perfeitamente no terminal

ÿ≤┼ÇÅ     Push "≤┼ÇÅ"
     $    pop(a), push ord(a) (pushes 2407581171)
      ∞   pop a, push 2*a

Utilizo o fato de que o MathGolf possui literais de 1 byte para criar seqüências de caracteres até o comprimento 4. Se eu quisesse converter o número inteiro de uma string de base 256, eu precisaria usar dois ", e a string seria 5 personagens. Dessa forma, economizo 2 bytes, mas perco um byte ao finalizar o operador de duplicação.

Python 3 34 Pontos

b=len("  ");c=b*b;d=c*b;e=d*b;g=e+d-b//b;print(c,d,e-b//b,e,g,g*b-c)

Python 3 , 44 38 19 18,5 bytes

-6 bytes graças a @Jo King
-50% bytes graças a @ouflak por apontar o bônus de 50%
-1 byte graças a @Dennis

for i in'밗ɯ*':print(ord(i),end='')

Experimente online!

Japonês, 10 9 bytes / 2 = 4,5

"0¢*"mc

Teste-o

Befunge-98 (FBBI) , 15 bytes / 2 = 7,5 pontos

"*H/!k-"*.*+..@

Experimente online!

Explicação:

Primeiro, empurre os valores ASCII dos caracteres '* + H /! K- (42, 72, 47, 33, 107, 45) nesta ordem para a pilha. Então calcule$4815 = 45 \cdot 107$ e $1623 = 33\cdot 47+72$e saída.

Encantos Rúnicos, 15/2 = 7,5

\>`*`
Rn$!;

Experimente online!

Simplesmente codifica os valores no menor número de bytes possível. 42, 16, 15, 8, E 4, coage-los com os valores numéricos, e imprime-los em ordem inversa. 4 8 15 16 42sem espaços, como 48151642era um formato de saída aceitável.

4e 8não pôde ser combinado ( 48), pois é numérico 0e não foi permitido o uso. É possível combinar os 15, 16 e 42 em 2 caracteres (em vez de 3) ʂàs custas de +1 byte, o que não valeu a pena.