Há cerca de um ano, em 31 de dezembro de 2015, tive a ideia de que:

Devemos fazer uma string de cápsula do tempo. Todo mundo começa a adicionar um personagem e nos próximos anos veremos quem pode fazer o melhor programa de todos os personagens com os esolangs existentes.

A maçaneta da porta coletou graciosamente os personagens da comunidade PPCG e os manteve em segurança por um ano.

Uma gritante 74 pessoas participaram por isso temos um spiffing 74 impressão ASCII personagens para jogar!

Aqui estão os 74 caracteres da sequência da cápsula do tempo de 2016 na ordem em que foram enviados:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Aqui estão os 74 caracteres da sequência da cápsula do tempo de 2016 em ordem ASCII (observe o espaço à esquerda):

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

Não é muito para trabalhar, mas por aqui gostamos de um desafio.

O desafio

Para determinar qual idioma é "melhor" com a sequência da cápsula do tempo, teremos 6 (para 201 6 ) desafios que aumentam em dificuldade em que em cada um você deve usar um subconjunto dos 74 caracteres da cápsula do tempo.

Ter 6 desafios distintos ajuda a garantir que mais idiomas possam competir, mas apenas os melhores idiomas poderão responder a todos e obter uma pontuação alta.

Pontuação:

• Cada desafio será pontuado de 0 a 74, dependendo de quantos caracteres são usados.
• Pontuações mais altas são melhores.
• Se o seu idioma não conseguir concluir um desafio, sua pontuação nesse desafio será 0.
• Qualquer subconjunto não vazio dos desafios pode ser concluído.
• Sua pontuação final é a soma das pontuações de todos os 6 desafios.
• A melhor pontuação final possível é 6 × 74 ou 444 .

Os desafios

1. Corra

Se o código de um idioma não puder ser executado em primeiro lugar, ele não poderá fazer nada.

Escreva o programa completo mais longo possível (usando apenas os 74 caracteres de cápsula do tempo, lembre-se) que é executado / executado sem erros de tempo de compilação ou tempo de execução.

Não importa o que o programa faça, não importa se tem entrada / saída ou entra em um loop infinito, apenas importa que seja executado sem erros. (Os avisos são válidos, assim como os erros causados ​​por uma entrada incorreta do usuário.)

Comentários são permitidos, portanto, isso pode ser tão simples quanto

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

em Python para uma pontuação de 74.

(Não tenha medo de responder se esse é o único desafio que seu idioma pode completar, mas também não espere muitos votos.)

Pontuação = duração do programa (programa mais longo é melhor)

2. E / S

Um idioma que não tem forma de entrada ou saída é quase tão inútil quanto um que não pode ser executado.

Dado um caractere ASCII imprimível de !(0x33) a }(0x7D) inclusive, produza o caractere ASCII imprimível antes e depois dele.

A saída pode ter um comprimento de duas cadeias ou lista ou os caracteres separados por um espaço ou nova linha.

Por exemplo, se a entrada for }a saída, pode ser |~ou ["|", "~"]ou | ~ou |\n~.

Da mesma forma, "é a saída para !e ACé a saída para B.

Pontuação = 74 - duração do programa (programa mais curto é melhor)

3. Ramificabilidade

Condicionais são frequentemente um requisito para a integridade de Turing , que geralmente é um requisito para um idioma ser útil.

Dado um número inteiro positivo, se ele terminar com os dígitos decimais 16, altere 6para a 7e produza o resultado; caso contrário, envie a entrada inalterada. Você pode usar seqüências de caracteres para entrada / saída, se preferir.

Exemplos:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

Pontuação = 74 - duração do programa (programa mais curto é melhor)

4. Loopability

Uma linguagem que não pode executar loops gerará código repetitivo tão tedioso que você precisará fazer uma pausa na programação por um tempo.

Dado um número inteiro positivo, imprima um quadrado da arte ASCII desse comprimento lateral preenchido com um padrão de quadrados concêntricos menores que alterna entre dois caracteres ASCII imprimíveis distintos . Eles não precisam ter os mesmos dois caracteres para entradas diferentes.

Por exemplo:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

Pontuação = 74 - duração do programa (programa mais curto é melhor)

5. Math

Uma linguagem que não é boa com números e matemática também pode ser para os cursos de humanidades.

Não aceite nada, mas produza os 72 divisores inteiros de 2016 , positivos e negativos, em qualquer ordem. A saída pode ser formatada como uma sequência ou lista de uma maneira razoável.

Exemplo:

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

Pontuação = 74 - duração do programa (programa mais curto é melhor)

6. Esoterismo

(Não, não é isso .) Nós da PPCG gostamos de nossas coisas esotéricas , e os quines são um bom exemplo disso.

Escreva o quine mais longo possível, de acordo com as regras usuais do quine . Um quine é um programa que não recebe entrada e sai por si mesmo.

Pontuação = duração do programa (programa mais longo é melhor)

Regras Específicas

• Em cada um dos 6 desafios, seu programa deve ser um subconjunto dos 74 caracteres da cápsula do tempo reorganizados da maneira que desejar. Pode ser um subconjunto vazio ou impróprio , portanto, cada um dos seus programas pode ter até 0 e 74 caracteres.
• Uma única nova linha final no final da entrada / saída / código está correta em qualquer lugar, pois alguns idiomas exigem isso ou não podem ser facilmente evitados.
• Salvo especificação em contrário, cada desafio pode ser concluído como uma função ou programa completo de acordo com nossos padrões .
• Todos os desafios devem ser concluídos no mesmo idioma.
• Você deve usar um idioma (ou versão de um idioma) criado antes de 2017 em qualquer lugar da Terra .
• Qualquer pessoa pode responder, independentemente de você ter adicionado um personagem à cápsula do tempo ou não.

_{Sinta-se livre para usar os personagens da cápsula do tempo de 2016 em seus próprios desafios.}

Glifo , 74 + (74 - 36) = 112

1. Execute (74 bytes)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 bytes)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

Explicação

O Glypho parecia uma boa escolha para esse desafio, porque não se importa com os personagens reais que estão sendo usados. Em vez disso, ele analisa grupos de quatro caracteres e escolhe o comando com base no padrão de repetição desses quatro caracteres. Como existem muitas duplicatas na string da cápsula do tempo, somos bastante flexíveis nos programas que podemos escrever, exceto pelo fato de estarmos limitados a programas com 18 comandos (o que não é muito no Glypho). Embora isso tenha me permitido resolver os dois primeiros problemas com bastante facilidade, duvido que o Glypho possa executar os outros com tão poucos caracteres.

Eu testei isso usando o interpretador Java recuperado de 23-06-2006 na máquina wayback , que usa um mapeamento ligeiramente diferente dos comandos:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

O programa Executar se traduz em:

1d-+[...]

Onde ...está algum lixo que eu não me incomodei em traduzir.

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

O programa IO se traduz em:

id1-+o1+o

Aqui está o que isso faz:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam, 74 + (74-14) + (74-26) = 182 pontos

1. Execute (74 bytes)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

Mover e#para a frente comenta a linha inteira.

2. E / S (14 bytes)

9`)ZH*+~):Q(Q)

Dennis salvou 8 bytes.

Explicação:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Ramificabilidade (26 bytes)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Explicação:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

Eu vou olhar para os outros mais tarde. ( EDIT : Duvido que sejam possíveis, sem literais de bloco ou string ... talvez o de matemática?)

J, pontuação 71 + (74-19) = 126

Tarefa 1, comprimento 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

Isso define um verbo AHILOcomo o interior. Não utilizado:

)))

Eu não acho que exista uma maneira de ficar mais tempo do que isso.

Tarefa 3, comprimento 19

+($#~$~4)=1e4|&%:*~

A maneira de executar esta tarefa sem restrições é a +16=100|]seguinte:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

Temos +, =e várias cópias, ou |à nossa disposição, e é fácil se locomover ], mas os números são mais problemáticos. Aqui está a primeira parte que calcula o módulo de entrada 100:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

Depois que terminarmos, vamos produzir o número 16. O caminho mais fácil é com *~4(4 multiplicado por ele mesmo), mas já o usamos, *então isso é proibido. Em vez disso, faremos alguma manipulação de array.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

Trabalhos

2

Isso é definitivamente impossível. As únicas maneiras de manipular os valores dos caracteres são a.e u:, e não temos acesso a nenhum deles.

Agora, se pudéssemos usar em avez de, digamos A,, isso seria uma solução:

Q{~(*^.4%9 1)+I.~&Q=:a.

A parte mais difícil de conseguir isso foi produzir o número -1.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

Isso gera a forma da casca, mas não consigo encontrar uma maneira de gerar caracteres. Alas.

5

É certo que esta parece ser a tarefa mais fácil de fazer em J. No entanto, sem i., isso será bastante difícil.

6

Provavelmente, isso é impossível sem uma fórmula falsa 449ou algo parecido, porque a cadeia da cápsula não contém aspas ou qualquer outra maneira de produzir cadeias J.

PowerShell - Pontuação total: 74

1. Corrida - Pontuação: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

Como isso é extremamente difícil no PowerShell (todo método possível de obter informações é impossível com os caracteres fornecidos, pelo que sei), pelo menos decidi aleatoriamente o primeiro desafio, para que nem todos copiemos o exemplo diretamente do post.

Então, aqui está um gerador de respostas aleatórias para um desafio (para idiomas em que #há um comentário):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Experimente online!

Memes , pontuação de ( 62 65 + 70) 135

1: Executar

Eu removi todos os backticks ( `) e operadores matemáticos. Eles entraram em conflito porque não havia números suficientes para satisfazer todos os operadores unários e binários. Deixei alguns, resultando em +3 bytes . Programa resultante:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

Não tenho idéia do porquê e como isso funcionou. Pelo menos, ele não lança nenhuma exceção de tempo de execução do C # e, portanto, não trava.

6: Quine

Você sabe, se houvesse uma -ou minúscula qem algum lugar desses 74 caracteres, isso seria muito fácil. Estou feliz pelo Ioperador, pelo menos.

1/4I

Este código não é exatamente óbvio. Aqui está uma explicação:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Sequências de frações (por exemplo 1/4) são exibidas com um I no final, para indicar exatamente isso. O Ioperador geralmente é inútil, eu o adicionei por outros meios, mas, ei, funciona assim!

O código acima é inválido. Estúpido, eu não vi que os 74 caracteres não contêm um operador de divisão única, forwardslash ( /). Eu vim com outra coisa, porém:

True

Explicação:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Saídas True(devido à maneira como o C # lida com Boolean.ToString()maiúsculas e não minúsculas). Não tenho certeza se essa é uma solução adequada, enquanto isso ainda estou quebrando minha cabeça por uma válida, realmente adequada e intuitiva.

Talvez também possa resolver o desafio de E / S e matemática, mas estou faltando tokens específicos (caracteres) que não estão incluídos nos 74 caracteres.

Brainfuck, 74 bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Eu só precisava.

Explicação:

Qualquer caractere que não seja um caractere válido do Brainfuck é tratado como um comentário. O único código que realmente é executado é o seguinte:

.+..

Isso não produz saída imprimível, pois nem 0 nem 1 são caracteres imprimíveis em ASCII. No entanto, como não causa erro, concluímos com êxito o primeiro desafio.

Mathematica, pontuação de 62

Ficaria surpreso se alguém puder fazer com que os desafios 2 a 6 funcionem no Mathematica. Aqui está o melhor que fiz no desafio 1:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Define uma função bastante estúpida Acom um valor constante. Os 12 caracteres não utilizados são:

)))\\`````{~

Oitava, pontuação 74

1. Corra

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

50 desses caracteres fazem parte da função, enquanto os 24 restantes não.

O que faz:

x =@(AHILOQQQTTZeefmpy)cria uma função xque pode receber uma variável AHILOQQQTTZeefmpycomo entrada.

Para entender o resto:

a||bchama a função all()em ambos ae b. Se um ou os dois retornarem true, o ||operador retornará true.

!ae ~asignifica a mesma coisa aqui, ambos são not(a).

a.^b é um poder em termos de elementos (a(1)^b(1), a(2)^b(2) ...)

Explicação continuada

Vou encurtar cada uma das etapas à medida que avança:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

E:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

Há um número par de not, então isso é equivalente a not(not(4))qual é trueou 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

O resto está comentado.

*> <> , pontuação total = 74

1. Corra, marque 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Experimente aqui!

Isso foi extremamente difícil de fazer sem o ;personagem. Na verdade, eu pensei que seria impossível por alguns momentos, até que eu vi o %, eu tinha basicamente desistido.

Este também é um programa> <> válido.

Explicado (partes irrelevantes omitidas)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Desafios enfrentados

Eu poderia tentar os outros desafios ... eles seriam extremamente difíceis e envolveriam as regras de maneiras estranhas, mas o uso liberal dos |espelhos e dos !trampolins deve possibilitar pelo menos mais um desafio.

Esses desafios são particularmente difíceis porque não são permitidas saídas com *> <> ( oe n), ou mesmo chamadas de função ( C), retornos de função ( R) ou terminadores de programa ( ;). Mesmo que também não haja ientrada, ainda podemos colocar a entrada na pilha, o que é uma vantagem. Outra vantagem é que obtemos uma única pinstrução, o que nos permite substituir uma instrução no codebox. Isso pode ser usado várias vezes (ainda não descobri uma maneira prática), o que começaria a tornar os outros programas mais possíveis (como poderíamos gerar duas ou mais instruções).

Haskell, pontuação 63

1. Execute:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

Não são usados )))```````{. Os comentários no Haskell são --ou {- ... -}, portanto, não há uma versão fácil para todos os comentários.

Este código define um operador infix !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~que recebe dois argumentos:

1. fmpxyAHILOQQQTTZ que é ignorado e, portanto, pode ser de um tipo arbitrário
2. e, que deve ser uma função que aceita dois números

No corpo da função, eé aplicado a 14 e 49, usando a `notação -infix.

Exemplo de uso:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

O operador é aplicado à ()tupla vazia e (*)ao operador de multiplicação, portanto, 14*49 = 686é calculado.

Experimente online!

Outros desafios

Duvido que qualquer um dos outros desafios seja possível, principalmente pela falta de possíveis nomes de variáveis ​​que podem aparecer duas vezes, o que é apenas e(ou algo parecido eQT), porque os nomes de variáveis ​​não podem começar com uma letra maiúscula. Claro, ter apenas um =também não ajuda.

Pyth, 131 por enquanto (2 desafios completos)

1. Corra, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

Este programa não aceita entrada e não cria saída.

Este programa utiliza $$, o que permite a execução arbitrária de códigos e, portanto, é banido online, portanto, este programa é executado offline. Aqui está sua saída de compilação, para que você possa ver o que realmente é executado:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

É bastante complicado escrever um programa com caracteres arbitrários que não erro no Pyth. Eu me propus o desafio adicional de exigir que o programa fosse executado sem a necessidade de entrada do usuário também.

O primeiro passo é usar #para comer todos os erros. Em seguida, precisamos evitar erros causados ​​por ~, Ie L, cada um com seus próprios detalhes. Isso é obtido colocando-os dentro de $$, que os incorporam na compilação de saída e, portanto, os sujeitam às regras de compilação do Python, não ao Pyth. Finalmente, para evitar a entrada do usuário, os vários tokens de arity 0 (variáveis ​​e similares) são colocados no final e os Qs são movidos para dentro do $$bloco.

2. IO

Isso será incrivelmente difícil, se é que é possível. Nenhuma das funções Pyth que criam seqüências ou caracteres arbitrários estão presentes .f, exceto , e isso faz um trabalho muito ruim na criação de caracteres arbitrários.

3. Ramificabilidade: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

Experimente online

Um programa Pyth equivalente seria:

?n%Q100 16Q+1

Esse código pega o mod de entrada 100, o compara com 16 e, em seguida, usa um ternário para escolher entre a entrada e a entrada mais um. Devido a restrições de caracteres, fiz algumas substituições:

• Em vez de ?, o ternário, usei |&, orentão and, que tem a mesma funcionalidade, exceto que quebra se a entrada for zero, mas como temos entrada inteira positiva garantida, tudo bem. (Isso poderia ter sido corrigido sem caracteres adicionais, mas é mais simples dessa maneira.)

• Em vez de comparar diretamente os dois números, tomo o XOR deles x, que é zero se e somente se forem iguais, conforme desejado.

• Em vez de escrever 100diretamente, eu o gero com *TT, uma vez que Té inicializado em 10.

• Em vez de escrever 16diretamente, eu o gero com ye|LZ9. |LZessencialmente funciona como a função de intervalo, então |LZ9fornece [0, 1, 2, 3, 4, 5, 6, 7, 8]. epega o elemento final de uma lista, dando 8. ydobra, dando 16como desejado. Com um extra +ou um extra, *eu poderia salvar um personagem, mas ambos são mais úteis em outros lugares.

Mais por vir!

Ruby - Pontuação: 74

1. Corra

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Agarrou-se com o desafio.

JavaScript (ES6), pontuação = 74

1. Execute, 74 bytes

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Esoterismo (inválido)

Para o registro, minha sugestão sugerida foi:

1.4e+49

que se mostrou inválido, conforme discutido nos comentários abaixo.

Retina, pontuação 74

1. Corra, marque 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

Mudei as parênteses extras para a configuração para que elas se equilibram na regex. Também mudei para a `direita depois disso e mudei +.para .+.

Experimente online

Os outros são provavelmente impossíveis, pois não há novas linhas. Também não -há transliteração ou dclasse de caracteres de dígitos.

Pip, pontuação 74 + (74-19) = 129

Tantos backticks com nenhuma citação para ser vista, simples ou dupla!

Tarefa 1, pontuação 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Basicamente, apenas uma série de literais padrão (regex) em backticks, o último dos quais é impresso. Como existe um número ímpar de backticks, temos que fazer uma barra invertida-escape de um deles ( `\``). Experimente online , com o -wsinalizador adicionado para provar que nenhum aviso é gerado.

Tarefa 3, pontuação 55 (comprimento 19)

e+!!e%(1.#x.!9)=4*4

Usando um método de entrada bastante estranho - o quinto argumento da linha de comando - isso é possível. Experimente online!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Outras tarefas

É possível obter entrada para a tarefa 2 , pelo mesmo método da tarefa 3 acima. O problema é converter para código ASCII e retornar para um caractere. O primeiro pode ser concluído A, mas o último requer C, ou possivelmente indexa na PAvariável. A construção e avaliação de código não podem ser dispensadas V. Não acho que a tarefa seja possível.

A tarefa 4 é desafiadora, mesmo sem um conjunto de caracteres restrito. Em suma, exigiria listas (sem usar os []delimitadores ou RL(lista de repetição) e apenas uma chance de usar AL(lista de anexos) - provavelmente não) ou possivelmente algo com CG(grade de coordenadas) ou MC(cordas do mapa), ambos não permitidos .

A tarefa 5 está à beira da possibilidade. Os loops seriam difíceis, pois For e Map não são possíveis e os intervalos não podem ser construídos com ,. Pode haver algo a ser feito com o Tmal. O incremento pode ser da x:x+1variedade (obviamente com uma variável diferente de x). As verificações de divisibilidade podem ser usadas %. Ainda assim, não acho que haja caracteres suficientes - especialmente cartas repetidas - para fazer tudo o que precisa acontecer.

A tarefa 6 parece completamente impossível. Todos os tipos conhecidos de Pip têm "neles. Eles também usam R(substituir), RP(repr) ou V(eval), nenhum dos quais está disponível.

Na verdade, pontuação (74 + 0 + 0 + 0 + 0 + 0 ) = 74

Sim, a string da cápsula funcionará com Actually como é para Run, pois Actually descarta qualquer erro e todo erro se torna um NOP.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%( Experimente online! )

No entanto, ele produzirá uma confusão de coisas (mas também sua fonte uma vez: 3).

Eu vou trabalhar em outros desafios, no entanto.

05AB1E - Pontuação total: 74

1. Execute, 74 bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Tudo o que causa um erro é ignorado por 05AB1E. Toda essa linha de código é um NOP.

Experimente online!

(abusado) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

O intérprete PHP simplesmente despeja o código fonte até encontrar um, uma <?vez que nos falta <toda permutação desses caracteres. Eu acho que isso não é pior do que usar um comando quine embutido: P

Mathematica, pontuação 68

`A: = .1% *. 44y # +. 9 ^` H @ `$ I @` L @ (`$ O ~` Q ~ `Q ~` Q ~ `T ~ T ~ Z ~ e ~ e | f | m | p | x) !!!!! & \

Observe a nova linha à direita. Não acredito que nenhum dos outros desafios possa ser alcançado com o Mathematica.

Labirinto, pontuação 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

Tenho certeza de que qualquer variedade desses caracteres produz um programa Labyrinth válido, mas, para torná-lo pelo menos um pouco mais interessante, isso imprime 2016dígito por dígito. (Em resumo: pressione 2 2na pilha, pop / imprima um, mova o outro para a pilha auxiliar, imprima 0, pressione 2 1na pilha, pop / imprima 1, incremente, bit a bit não, negue (a última 1é 3a neste ponto), soma com o 2da pilha auxiliar, 5 * 10 + 4 = 54, imprime como valor ascii, termina)

A maior parte da linha longa é simplesmente ignorada, pois @finaliza o programa.

Os desafios 2, 3 e 4 são impossíveis, pois nenhum dos comandos de entrada do Labyrinth está disponível ( ,ou ?) e eu não criei nada para 5 ou 6.

SmileBASIC, 48 pontos

desafio 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

explicação:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

outras:

Nenhum comando de entrada / saída está disponível; portanto, o restante não é possível.

Ainda assim, não é ruim para um idioma real sem usar comentários.

MATL , pontuação total 74

1. Corra, marque 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Tudo até %é código real. %é um símbolo de comentário, portanto, os caracteres à sua direita são ignorados.

O programa sai 1sem erros.

Experimente online!

bash, score 74

1: Execute. Podemos executar todos os 74

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Esoterismo:

O programa vazio é um quine no bash.

Sem caracteres de espaço em branco, nada mais pode ser realizado na lista. Portanto, eu tenho a entrada vencedora do bash.

Perl 6 , pontuação total 74

1. Corra, marque 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

Sem comentários.
(Basta colocar a #parte da frente para fazer tudo o que um comentário também funciona, mas isso é mais divertido.)

Trabalhos

Este é o subconjunto do idioma Perl 6 que usa apenas os caracteres permitidos:

Constantes: e

Nome do tipo: IO

Funções: exp

Métodos:
    no tipo IO: .e .f .x
    (... provavelmente mais.)

Operadores: | infixo: | prefixo:
    ----------- + ----------------------- + ---------
    numérico: | + * + ^ + | + &% | + + ^
    string: | ~ x ~ ^ ~ | ~ & | ~
    booleano: | || ~~ !
    junções: | | & ^ |  
    misc: | =: = Z .. ... |  

sintaxe:
    números literais: 1 4 9
    literais de cadeia de caracteres: Q` `Q! ! etc.
    comandos de shell: Q: x` `Q: x! ! etc.
    Qualquer estrela: *
    variáveis: my \ $ @ &
    agrupamento: ()
    comentários: # # `()
    unspace: \

O obstáculo imediato que impede os desafios de 2 a 6 é que não parece haver uma maneira de fazer E / S:

• Se assumirmos que existe um arquivo chamado f, poderíamos usá Q`f`.IO.e-lo para verificar se ele existe ou Q`f`.IO.xpara verificar se é executável. Mas não podemos ler ou escrever a partir dele.

• Nós poderíamos usar Q:x` `para executar um comando shell (assumindo que encontramos os caracteres para um). Mas não podemos interpolar nada, então seria bom apenas ler, não escrever.

• Como não há chave de fechamento, não podemos criar um bloco lambda (por exemplo {1 + $_}) que retorne automaticamente o valor de sua última instrução.

• Nós poderia usar o asterisco para fazer um lambda expressão (por exemplo 1+*), mas então nós só pode ter um argumento, referem-se a este argumento apenas uma vez, e são ainda mais limitadas na sintaxe / operadores que podemos usar.

Lua, pontuação 31

1. Corra (31 de 74 pontos)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

Geléia , pontuação 74

1. Corra , 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

Não sei como fazer qualquer um dos outros.

/// , Pontuação: 146

1. Corrida, Pontuação: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Pontuação: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Sim, quando não há barras no código, ele apenas se imprime.