Nenhuma sequência (ou número) anexada


71

Se você gosta disso, considere participar de:


Faça 12 trechos / expressões , no mesmo idioma, que resultem nos números de 0 a 10 e 42, respectivamente, mas sem gravar dados numéricos, de seqüência de caracteres ou caracteres literais.

Dados incorporados , como PI()e ALPHABET(), são bons, assim como, por exemplo, as constantes U, X, Y, Z e A de CJam, e as combinações BLEND, CHORD, CENTER, BREAK e LINES do Processing.

Todo snippet deve ser capaz de se manter por conta própria, ou seja, eles podem não ser interdependentes. No entanto, dentro de um único trecho, você pode atribuir uma variável e usá-la livremente, desde que se refira diretamente a ela pelo nome, e não por meio de uma string que contenha seu nome.

Todos os trechos devem ser válidos no computador do remetente no momento do envio (conforme relatado pelo SE), mas não podem depender de condições locais incomuns, como número de arquivos em um diretório, data ou hora exata ou entrada específica do usuário .

Exemplos de trechos válidos

3: INT(LOG10(YEAR(TODAY()))) porque permanece verdadeiro no futuro previsível
4: CUBICROOT(LEN(CHARACTERSET())) porque um conjunto de caracteres de 256 letras é muito comum
8: SQRT(SYSTEMTYPE()) porque sistemas de 64 bits são muito comuns

Exemplos de trechos inválidos

5: LEN(USERNAME()) porque a maioria das pessoas não usa "Admin" como login :-)
9: LOG10(SYSTEMMEMORY()) porque funciona apenas em sistemas com exatamente 1 GB de memória
42: CODE("*") porque contém um literal de cadeia / caractere

O resultado de cada snippet deve resultar em um número real (valor, int, float etc.) que pode ser usado para cálculos adicionais usando o mesmo idioma do snippet, ou seja, não uma sequência de texto representando esse número.

Somente idiomas baseados em caracteres são permitidos.

A pontuação é a contagem total de bytes de todos os 12 snippets combinados. As novas linhas que separam os trechos não são contadas.

Observe que as regras acima podem impedir a participação de alguns idiomas, mesmo que eles estejam completos no Turing.

Perguntas frequentes

P Os programas podem aceitar qualquer entrada?
R Sim, mas você pode não apenas solicitar entrada e inserir o número relevante.

P Os dígitos físicos (não dados) são permitidos?
A Sim, por exemplo LOG10().

P Os símbolos no Ruby contam como literais?
R Sim.

P A pontuação inclui novas linhas entre cada snippet?
A No.

P O TI-BASIC "baseado em caracteres" é suficiente para ser válido?
R Sim.

P Falso e verdadeiro contam como literais numéricos?
R Não, eles são aceitáveis.

P Podemos usar um literal numérico para chamar uma função se essa for a única maneira e o número não influenciar a saída da função?
R Sim, se essa for a maneira normal de escrever código no seu idioma.

P Minha linguagem assume que existe um [algo] no início de cada programa / expressão. Devo incluí-lo ou meus trechos devem funcionar se colocados no meio de um programa / expressão?
R Eles devem apenas trabalhar no meio de um programa / expressão.

P E os literais regex?
A Proibida, com exceção de línguas que apenas fazer expressões regulares.

P É aceitável um pedaço de código que possa imprimir todos os números especificados?
R Não, eles precisam ser separados e independentes entre si.

P Posso assumir um padrão semelhante int main() {}...ou equivalente?
R Sim.

P Quais tipos de dados de saída são permitidos?
A Qualquer tipo de dados numérico, como int, float, etc.

P Preciso imprimir o resultado de cada snippet?
R Não, disponibilizar o resultado para uso posterior é suficiente.

P São permitidas variáveis ​​predefinidas?
R Sim, e eles são redefinidos (se alterados) para cada trecho.

Q π e e são considerados literais numéricos?
R Não, você pode usá-los.

P Posso retornar 4 e 2 em células diferentes para 42?
R Não, eles devem estar conectados como um número.

P Bytes ou caracteres?
A Bytes, mas você pode escolher qualquer página de código desejada.

P Podem ser usadas funções constantes e variáveis ​​predefinidas como J 9:, Actually 9e Pretzel 9?
R Sim, se o vocabulário for finito (19 para J, 10 para Actually e Pretzel).


Se 0-9 não são literais numéricos, mas são variáveis ​​pré-preenchidas, seria um jogo justo?
Cyoce

@ Cyy Então 10 é {1, 0} e não 2 × 5?
Adám 29/08/16

não, existe simplesmente outra sintaxe para literais que não é base-10, portanto, 0-9 não são literais. Eles mantêm o valor de 0-9, mas são considerados variáveis
Cyoce

@ Cyoce Então está tudo bem. Que língua é essa?
Adám 29/08/16

pretzel (um idioma em que estou trabalhando).
Cyoce

Respostas:


15

Hexagonia , 13 bytes

1 1
2
3
4
5
6
7
8
9
10
42.

Experimente online!

No Hexagony, 0through 9são funções que multiplicam a memória atual por 10 e adicionam o número representado pelo nome da função. Portanto, o primeiro trecho está vazio quando as memórias começam como 0.

Por exemplo, se a memória atual estiver 65, a execução da função 3criará a memória atual 653.

(Para os que votam para baixo: votem para baixo quanto quiserem; eu estou pronto.)


Sorrateira, mas recebe meu voto positivo e marca.
Adám 23/08/16

49

Função , 1222 bytes

Além dos literais numéricos, há duas maneiras de produzir um valor (qualquer valor) no Funciton: expressões stdin e lambda. Stdin é uma caixa única, enquanto uma expressão lambda completa requer mais sintaxe, então eu vou com stdin. No entanto, embora stdin possa ser qualquer coisa, todos os trabalhos a seguir, independentemente de qual entrada é fornecida.

Todas as funções de biblioteca usadas aqui existiam antes do lançamento do desafio.

0 (40 bytes em UTF-16)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

Isso usa a sintaxe bruta por menos que. Um valor nunca é menor que ele próprio, portanto, o resultado disso é 0.

1 (52 bytes em UTF-16)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

retorna uma sequência lenta que contém um único elemento e ɕconta o número de elementos. (A sequência lenta é preguiçosa o suficiente para que esse trecho não avalie realmente o stdin!)

2 (70 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2¹. ʂgera todas as subsequências de uma sequência e, assim, transforma uma sequência de n elementos em um com 2ⁿ.

3 (88 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. incrementa um valor em 1.

4 (88 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2².

5 (106 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1.

6 (106 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 fatorial.

7 (110 bytes em UTF-16)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A (2, 2) (função Ackermann).

8 (118 bytes em UTF-16)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (shift-esquerda).

9 (128 bytes em UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3.

10 (146 bytes em UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5.

42 (170 bytes em UTF-16)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1).



4
Eu gostaria de poder votar mais de uma vez ...
ev3commander

26

JavaScript, 144 141 140 138 132 125 123 bytes

Com a ajuda de @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn e @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];
<pre id="result"></pre>


Tente 4: - ~ Math.PI
edc65

@ edc65 Obrigado! Eu pensei que haveria algo que eu poderia fazer com o PI. :)
user81655

Para 5, 6, você também pode usar -~-~Math.PIe -~-~-~Math.PIsalvar outro byte (duas vezes).
Sjoerd Job Postmus

11
Salve um em 42 com (escape+NaN).length. PS Hoje eu aprendi que o JavaScript é realmente estranho ...
Mwr247

11
Eu diria que NaNconta como um número, mas é literalmente Não é um número: P
ETHproductions

17

Mouse-2002 , 27 26 17 14 bytes

Os primeiros trechos pressionam 0-10 e ZR+empurram 25então 17e 25 17 + 42 =é 1.

A
B
C
D
E
F
G
H
I
J
K
ZR+

Ele diz "um trecho ou expressão" para que você possa remover todos os! 'S
ev3commander

3
@cat Eu não posso falar pelo interlocutor, mas acho que isso significa ficar sozinho um do outro - sem definir uma função em um e usá-lo em outro. No entanto, cada trecho não precisa ser um programa inteiro; ele pode assumir o int main() {}...equivalente padrão que o fará executar.
usar o seguinte

15

CJam, 27 24 bytes

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

Obrigado a @ MartinBüttner por -1 byte!

Experimente online!


12

Brainfuck, 70 bytes

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

Cada linha deve ser executada individualmente.

Os 10 primeiros são auto-explicativos: incrementamos o valor da célula via cada mais.

O 42 é muito mais complexo. Ele se baseia no fato de que o intérprete mais covarde usa células de 8 bits, o que significa que todas as operações nele são realizadas no módulo 256. --Define a célula # 0 a 254. Em seguida, inserimos um loop que é executado até a célula # 0 ser 0. Cada iteração adiciona 1 à célula nº 1 e adiciona 6 à célula nº 0. Esses loops são executados 43 vezes, então a célula 1 é 43. Finalmente, subtraímos 1 da célula 1 para torná-la 42.

Eu consegui os 42 mais eficientes já encontrados em http://esolangs.org/wiki/Brainfuck_constants


11
@someonewithpc 4 e 2 é diferente de 42: o OP diz que O resultado de cada snippet deve resultar em um número real que pode ser usado para cálculos adicionais usando o mesmo idioma do snippet, ou seja, não uma sequência de texto representando esse número . Você pode fazer cálculos diretamente no 42, mas não é o mesmo para 4 e 2 em células separadas.
p1xel

Ah ok. Eu tinha perdido isso ..
someonewithpc

12

Escuridão , 339 303 bytes

É aqui que a escuridão realmente brilha . Pegue? : ~)!

Sem impressão (substituiu o espaço \sna primeira linha, pois não será exibido de outra forma):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

Com impressão:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

Cada linha deve ser executada individualmente neste caso, pois o programa termina na luz (um espaço). No entanto, é possível escrever isso em uma ou várias linhas no mesmo programa.

A escuridão regular (█) incrementa um registro em 1, e a instrução ■ (algum tipo de mini-escuridão) gera o conteúdo do registro.


Acho que isso não requer programas completos, apenas trechos.
Erik the Outgolfer

12

Perl 5, 86 75 71 66 bytes

Todos os ^Fs são caracteres de controle literais (0x06 em ASCII) e, portanto, um único byte.

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

Obrigado ao msh210 por salvar 11 bytes e ao Dom Hastings por 9 bytes!


3
ldam

downgoated porque "número máximo do descritor de arquivo sys, 2 em todos os sistemas sãos = 3", mas eu tenho 65+
cat

(Estou apenas brincando, votei melhor, é claro) #
cat

11
Você já leu os comentários em um post do SE e pensou: "uau, que idiota escreveu isso"? Essa sou eu agora, comigo mesma.
gato

!$[+ord$/ # -1 + 10Eu não entendo. Na linha 2 você disser que !$[lhe dá 1, não -1, então esse trecho dá 11.
Timwi

10

MATL, 30 bytes

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H, I, E Ksão constantes predefinidas para 2, 3, e 4 (como pi). Oe lsão funções que retornam uma matriz de zeros ( O) ou uns ( l), o tamanho padrão é 1x1. :faz um vetor e o ssoma, então K:sfaz um vetor de 1 a 4 e o soma para obter 10. Yqé a n-ésima função primária, assim KYqcomo o quarto primo, 7.


Essa Yqfunção (e sua implementação) foi uma agradável sugestão de vocês :-)
Luis Mendo

IK+funcionaria tão bem para 7, mas é um pouco chato: P
David

10

Prolog, 113 99 bytes

Trechos:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

Combina as constantes matemáticas e e pi de diferentes maneiras convertidas em int.

Editar: salvou 14 bytes utilizando flutuadores para 0-2.


11
algo de errado com e / e = 1?
Level River St

@ steveverrill: ele se tornará um float (1.0). Interpretei a descrição do desafio como significando que os números deveriam ser números inteiros. A maioria delas, se não todas, poderia ser reduzida de outra maneira.
Emigna

11
@steveverrill Os flutuadores estão bem. Nós apenas precisamos do valor certo .
Adám

9

PHP, 157 145 91 bytes

A primeira vez que publiquei no Code Golf, achei que eu tentaria. Eu melhorarei eventualmente: P Se você encontrar algum ponto óbvio (para você) onde eu possa salvar personagens, me avise.

Edição: Percebi que não precisava de ponto e vírgula, uma vez que estes são apenas trechos.

EDIT2: Obrigado ao Blackhole por muitas sugestões!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

5
O PHP tem muitas extensões e, portanto, muitas constantes predefinidas muito melhores do que as matemáticas para esse desafio;). LC_ALLpara 0 (-1 byte), DNS_Apara 1 (-3 bytes), LOCK_NBpara 4 (-3 bytes), LC_TIMEpara 5 (-7 bytes), LOG_INFOpara 6 (-8 bytes), INI_ALLpara 7 (-5 bytes),…
Blackhole

5
IMG_WBMPPara 8 (-4 bytes), SQL_DATEpara 9 (-9 bytes), SQL_TIMEpara 10 (-3 bytes) e LOG_INFO*INI_ALLpara 42 (-11 bytes). Portanto, um total de 51 bytes salvos! Essas constantes são válidas pelo menos no PHP 5.6.1 no Windows.
Blackhole

@Blackhole não é LC_ALLuma coisa dependente de localidade?
gato

@cat É realmente uma constante usada setlocale()para alterar todas as categorias de localidades. Mas o valor da constante em si é obviamente independente da localidade :).
Blackhole

@ Blackhole ah, entendo!
gato

9

Python 2, 191 159 158 157 156 149 146 bytes

Minha primeira submissão, espero ter acertado tudo! Com base no tempo que gastei nisso, acho que certamente há um melhor para alguns deles.

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

Muito obrigado a FryAmTheEggman!


Bem-vindo ao PPCG :) Não tenho 100% de certeza sobre esse desafio, mas acho que o uso Truecomo idioma para 1 deve ser aceitável, pois não sei quando eles não são equivalentes a trechos.
FryAmTheEggman

Oh, você está certo! Não usá-lo para o 1 em si, porque, True is not 1mas para todo o cálculo baseado em 1, ajuda! Editando agora.
Joachim Jablon

11
Use #8 len(`id(id)`). Então 8, 9 e 10 serão mais curtos. Além disso, talvez adicione um hiperlink para Experimente online .
mbomb007

Você pode obter 9 com len(`{()}`)11 bytes, e isso fornece de 7 a 10 menores.
xnor

9

C #, sem usos, 234 bytes

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

Isso é muito mais chato do que eu pensava inicialmente. Eu tinha idéias bastante variadas, como new[]{true}.Lengthe true.GetHashCode()e typeof(int).Name.Lengthe uint.MinValueetc., mas new int()venci todas elas.


As regras permitiriam que você fizesse algo assim var a = new int();e depois usasse aem cada trecho?
Ld 18/12/2015

@LoganDam: Acho mais interessante se todas as expressões tiverem de se sustentar sozinhas. Por isso também não usei nenhuma usingdeclaração.
Timwi

Whoa, o que são esses para 9/10/42: Oo
ev3commander

@ ev3commander: Eles são simplesmente os valores de enumeração mais curtos definidos no mscorlib que possuem o valor inteiro necessário. Para ConsoleKey.Tab, o valor 9 não é surpreendente (9 também é o ASCII do caractere de tabulação). Os outros são provavelmente arbitrários.
Timwi

Um menor para 8:int a=-~-~new int();a<<a
LegionMammal978

9

PowerShell, 147 bytes

Eles são usados +para converter implicitamente coisas em números inteiros. Os números posteriores usam Enums dos limites do .NET Framework do PowerShell, que possuem os valores corretos.

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

  • -~-~-~usado em JavaScript, as respostas C # e PHP estariam - -bnot - -bnot - -bnotno PowerShell.

  • x^yexponenciação usada em respostas Perl, ou x**yem Python ou JavaScript ES7, seria[Math]::Pow($x,$y)

  • constantes e e Pi são os caracteres pesados [Math]::Ee[Math]::PI


x^yé xor em JavaScript. O JavaScript (ES7) possui **para expoentes. Fonte
mbomb007 03/03

@ mbomb007 Ah, obrigado - eu atualizei minha nota sobre isso.
precisa

@ mbomb007 eu ainda acho que é meio bobo
SuperJedi224

@ SuperJedi224 Por que? É assim que o Python faz isso. E o xor é um operador importante.
mbomb007

8

DC , 35 bytes

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

Para testar os trechos, anexe a fpara imprimir a pilha e passe essa sequência para dc:

$ echo 'EdE++f' | dc
42

Eu acredito que Ee Faqui estão os dígitos (mesmo quando são maiores que o raio de entrada). A evidência para isso é que eles combinam como dígitos; por exemplo F0-> 150. Você pode ver o mesmo comportamento com dígitos decimais depois de alterar o raio de entrada e saída.
precisa

Existem muitas outras respostas usando coisas semelhantes ... por que eu deveria ser a única onde isso não está bem?
yeti 02/03

Você não deveria - se houver outras soluções usando dígitos, elas também não serão respostas válidas.
amigos estão dizendo sobre taby Speight

11
Eu não ligo mais! O Codegolf até aceita um programa gráfico definido como mandelbrot como solução para a tarefa de escrever um programa ascii art mandelbrot ... o codegolf precisa de uma grande redefinição e, quando reiniciado, posso ou não me importar com as regras novamente ...: -Þ
yeti

7

TI-BASIC, 41 bytes

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42:

int(π²/ecosh(π

No TI-BASIC, todas as variáveis ​​de uma letra não inicializadas começam em 0 e Xmax(o limite direito da tela da tela do gráfico) começa em 10.

A constante matemática πé de um byte , mas etem dois bytes.


Π não são considerados dados numéricos?
vsz

@ VSZ talvez, mas não é um número literal. A operação diz isso.
SuperJedi224

@NBZ ponto muito bom. Minha culpa.
GamrCorps

6

Python 2, 306 275 274 bytes

Eu usei o fato de que para qualquer x (número inteiro e não 0) a expressão x/xé igual a 1 e brincamos com algumas operações bit a bit.

Ajustei os trechos de forma que eles ainda atendam aos requisitos (graças a @nimi isso me salvou em 24 bytes), mas você deve testá-los manualmente. Aqui está o código e a contagem de bytes individuais:

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

Você pode salvar bytes comi=id(id);r=~i/i
Cyoce

6

Math ++, total de 92 bytes

0 (1 bytes): a

1 (2 bytes):!a

2 (3 bytes):_$e

3 (4 bytes): _$pi

4 (7 bytes): _$e+_$e

5 (8 bytes): _($e+$e)

6 (9 bytes): _$pi+_$pi

7 (8 bytes): _($e*$e)

8 (9 bytes): _($e*$pi)

9 (10 bytes): _($pi*$pi)

10 (12 bytes): _$e*_($e+$e)

42 (19 bytes): _($pi+$pi)*_($e*$e)


5

Javascript (navegador Env), 155 136 130 bytes

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

Graças a:
@Ismael Miguel : 155 -> 136 -> 130 bytes


11
Você pode usar -~[]+[]+-[]para produzir 10. Ele retornará uma string, mas ainda poderá ser usada como um número. Além disso, você pode usar -~(top+top.s).lengthpara calcular 42(-8 bytes) e diminuir sua dependência no Google Chrome. Para economizar mais 3 bytes, use o (P=Math.PI)*P>>+[]cálculo 9.
Ismael Miguel

11
Desculpe, esqueci alguns bytes que você pode raspar. Você pode usar ~(~[]+[]+-[])para gerar 9. Isso deve reduzir mais alguns bytes.
Ismael Miguel

curiosamente, +[12]12e +[1, 2]NaN. Eu odeio JS
cat

2
@cat É por causa do sistema de elenco estranho do JavaScript. Matrizes convertidas em strings como [1,2,3]=> "1,2,3"e strings convertidas em números como "12"=> 12mas se houver caracteres não numéricos na sequência, o elenco retornará NaN. +[1,2]lança para uma sequência e depois para um número, mas a sequência contém uma vírgula e "1,2"se torna NaN.
user81655

@ user81655 isso. é. HORRÍVEL.
cat

5

Sério, 39 33 bytes

Coisas entre parênteses são explicações:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

Hexdumps de programas:

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

Graças à quintopia por 6 bytes!


11
Suponho que use seriamente uma página de código de 256 caracteres que inclui caracteres pseudo-gráficos?
Adám

2
@NBZ CP437
Mego

Você pode salvar um byte no 6 com Hl▓
quintopia 20/12/2015

A mesma idéia com ú salva um byte em 9
quintopia 20/12/2015

HlPDsalva 2 bytes em 42, e QlPsalva um byte em 7, e Qlªsalva um byte em 9 e Ql╙salva um byte em 8. Acho que isso reduz seriamente os 33 bytes ao todo, amarrando Pyth.
quintopia 21/12/2015

5

dc, 42 bytes

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

Resultados

0
1
2
3
4
5
6
7
8
9
10
42

Não há muitas maneiras de gerar novos números com dc. Eu uso O: base de saída, inicialmente 10; K: precisão, inicialmente 0; zprofundidade da pilha, inicialmente 0; Zdígitos significativos do operando. Nós os combinamos com os operadores aritméticos usuais.

Programa de teste

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

4

Mathematica, 101 bytes

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

Tenho certeza de que alguns deles são abaixo do ideal. Esses colchetes são realmente caros.

Para consistência, os dois primeiros também poderia ser E-Ee E/Eé claro, mas eu pensei que é muito bacana para chegar 0e 1partir de um cálculo com variáveis indefinidas.


@NBZ Desculpe, esqueci 0. Se aobtiver o valor 0posteriormente, isso não será um problema, desde que não seja utilizado quando a/afor avaliado.
Martin Ender

@NBZ A contagem de bytes é simplesmente a contagem de bytes UTF-8.
Martin Ender

4

Japonês , 34 33 30 bytes

1 byte salvo graças a @ThomasKwa

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

Aqui está o que cada um dos diferentes caracteres significa:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

O Japt aceita números hexadecimais por padrão? Se sim, então A a F seriam literais numéricos ...
Adám

@NBZ A-Isão variáveis ​​que, por padrão, são atribuídas a vários números, como mostrado acima. A-Fsão atribuídos a 10-15. Isso invalida essas variáveis?
ETHproductions

Não. Eu só estava me perguntando se, digamos, 12AB3 era válido. Agora eu sei que não é. Aqui não há literais, avance. :-)
Adám

4

Marbelous , 98 bytes

Não é muito empolgante, depende dos ?ndispositivos que transformam qualquer mármore em um valor aleatório no intervalo 0..n (inclusive), um efeito colateral disso é que ?0transforma qualquer mármore em um 0, independentemente da entrada. Eu acho que o uso de literais é permitido porque o valor não afeta o resultado e não há outra maneira de chamar uma função uma vez no Marbelous.

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L

Parece que 0 ... L são literais numéricos.
Adám

2
@NBZ Eles não são, você não pode usá-los independentemente. +0 a + Z são como funções integradas. É chato, mas válido.
overactor

4

> <> , 86 bytes

  • 0: ln;
  • 1: lln;
  • 2: llln;
  • 3: lll+n;
  • 4: lll:+n;
  • 5: llll+n;
  • 6: llll++n;oullll:+n;
  • 7: lllll+n;
  • 8: lllll:+n;
  • 9: lllll++n;oullllll+n;
  • 10: llll+:+n;oulll:l+*n;
  • 42: llll*ll+*n;

Depende do tamanho da pilha para obter seus literais.


Provavelmente, você pode remover o nem cada um porque as funções em idiomas baseados em pilha podem deixar a saída na pilha por -11 bytes.
Reddarcoder

@redstarcoder então eu poderia até remover o ;total de 22 bytes e considerar o final da função atingida no final da linha, mas é um pouco ambíguo, pois ><>não possui funções prontas para uso.
Aaron

Tecnicamente, se você deseja funções ><>, suas funções precisam aceitar uma posição de retorno (x & y) na pilha, além de seus parâmetros, verifique se elas não atrapalham os cálculos ( [é útil nesse contexto), depois pule para a posição de retorno após concluir a execução. Eu tinha feito um POC há um tempo atrás, confira se você estiver interessado
Aaron

Eu já vi sua postagem antes, e bom trabalho! Eu fiz um meta post sobre as ambiguidades das funções . O que estou dizendo é que isso normalmente é permitido, com o ;. A razão pela qual eu digo para sair ;é porque, caso contrário, não há como denotar quando a função termina sem a .. A maioria das pessoas parece considerar isso justo, mas eu poderia tentar escrever uma meta post específica aqui, se você estiver preocupado.
Reddarcoder 5/12/16

11
@redstarcoder obrigado pela informação! Eu sinto que sufocar os ><>trechos .seria a melhor maneira de manter a definição de função, conforme descrito na resposta mais votada do meta post, no entanto, eu concordo que ;é uma boa alternativa que requer menos explicações.
Aaron

4

Fórmulas do MS Excel, 163 151 150 143 bytes

Não é exatamente uma linguagem de programação, mas aqui vai ...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()é usado na maioria dos casos, pois é a maneira mais curta (que eu conheço) de introduzir um valor numérico sem usar um número ou string literal. Nconverte várias coisas (incluindo booleanos) em números e Tconverte várias coisas em texto. TYPEretorna 2 para um argumento de texto e 4 para um argumento booleano. TRUNCdescarta a parte fracionária (ou seja, arredonda números positivos para baixo), EVENarredonda para o próximo número par e ODDarredonda para o próximo número ímpar. CODE(-PI())é o código ASCII do primeiro caractere da conversão para o texto de -π, ou seja, 45 (para "-").

EDIT: Removidos sinais de igual da contagem de bytes (-12!) - como apontado por Nᴮᶻ nos comentários, eles não devem ser incluídos.

EDIT 2: Supondo que o restante da planilha esteja vazio, é possível usar uma referência a uma célula vazia como zero (novamente, sugerido por Nᴮᶻ), desde que inclua um sinal de menos (ou use-o em outra expressão numérica) para resolver digite ambiguidade.


0=Z9
Adám

Removido os =, obrigado. Em relação à sua sugestão, evitei referências de célula de propósito, para garantir que as fórmulas sejam independentes do conteúdo da tabela - se Z9contiver um texto, =Z9não retornará mais zero. Decidi não assumir nada sobre a mesa.
DNEP

de qualquer maneira, você me fez saquear nele outra vez, e eu percebi que poderia salvar pelo menos 1 byte usando a 0 a mesma lógica que eu usei para 1 ...
DNEP

Mas alguns idiomas têm todas as variáveis ​​definidas como 0 se não estiverem definidas para outra coisa. Nesse contexto, eu consideraria o Excel uma linguagem com células de memória (teoricamente infinitas) A1: ZZZ ..: 999 ... e sem distinção entre código e dados do programa (ou seja, pode ser auto-modificável). Como cada trecho é independente dos outros, presumo que ele esteja em A1 e o restante da folha em branco. (Para programas, eu teria um comunicado conjunto, em cada célula A1, A2, etc.)
Adám

Entendo o seu ponto ... mas há um problema adicional com as referências de célula: Z9em uma planilha vazia é um valor vazio que é convertido 0em muitos casos, mas pode ser convertido em ""(string vazia) se usado em algumas expressões - como uma variante não inicializada do VBA - portanto, não é estritamente equivalente a 0. Por exemplo, = 0&"a" é avaliado como "0a"mas é = Z9&"a"avaliado "a". Isso pode ser resolvido, no entanto, adicionando um unário -à referência (forçando-o a ser numérico - novamente, como no VBA). Então -Z9 pode ser usado como zero. Acabei de atualizar a resposta. Obrigado novamente.
DNEP

4

DUP , 68 bytes

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

Existem muitas maneiras de fazer isso, mas estou abusando da pilha de retorno dessa.

Explicação

Para entender isso completamente, você precisa entender o comportamento do DUP em relação às lambdas. Em vez de enviar o próprio lambda para a pilha, ele realmente envia o IP atual para a pilha quando o lambda é detectado. Isso pode explicar os três primeiros trechos, que envolvem lambdas.

Os próximos trechos usam a pilha de retorno. Quando !é executado, o IP atual é enviado para a pilha de retorno e a parte superior da pilha é definida como o novo IP para iniciar a execução do lambda. )aparece um número da pilha de retorno na pilha de dados.

Isso é o suficiente para explicar o restante dos trechos. Se você ainda não o recebeu, lembre-se de que o Stepbotão é bastante útil!


4

05AB1E, 40 38 24 bytes

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+
  • Push counter_variable
  • Push 1
  • Push 2
  • Pressione 1 + 2
  • Pressione 2 * 2
  • Push 10/2
  • Empurre (10/2) +1
  • Empurre (10/2) +2
  • Push 10-2
  • Push 10-1
  • Push 10
  • Pressione 32, 10, adicione

11
é mais limpo da pilha que Yx, Xpode ser usado em vez de ºaqui (o padrão é 1, ºsignifica len(stack)>1, portanto, não é o padrão para nada). Além disso, seu número de bytes é 24, não 35 (CP-1252, as novas linhas não contam se forem trechos separados).
Erik the Outgolfer

Eu sei que ainda não era possível no momento em que você postou isso, mas ₆tagora pode ser 6 (push 36, raiz quadrada) para salvar um byte ( Experimente online ).
Kevin Cruijssen 29/03

3

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

Cada linha é um trecho diferente.

Os números no programa não contam como literais numéricos, pois são usados ​​apenas como comandos.

O último pode definitivamente ser jogado mais.

Edição: Eu tenho o intérprete trabalhando e todos os trechos funcionam. Se você quiser testar se, adicione 0f0fno final do snippet para que o programa seja encerrado.


6
Aqueles com certeza parecem literais para mim. Além disso, não poste código que você não testou.
Mego

2
Você pode explicar como eles funcionam?
Adám

O @NBZ D1ffe7e45e funciona com base na diferença entre dois números hexadecimais. Essa diferença é então interpretada em um comando. Por exemplo, a diferença entre 0 e 2 é 2, que é interpretado como o comando de incremento (como +em Brainf ** k). Eu pensei que, como eles estavam sendo usados ​​como comandos e não como literais numéricos, ainda contava. Excluirei a resposta, caso contrário.
ASCIIThenANSI

@ Megego, tenho o intérprete trabalhando e meu código funciona. Veja o comentário acima para saber por que eu acho que eles não são literais.
ASCIIThenANSI

11
Eu não acho que nada disso seja literal. No entanto, acho que você não deve imprimir os números, pois o resultado de cada snippet deve resultar em um número real que pode ser usado para cálculos adicionais .
Dennis

3

Pyth, 35 34 33 bytes

-1 byte por @Mimarik

Existem várias possibilidades para alguns programas.

0, 1 byte

Z

1, 2 bytes

hZ
!Z

2, 3 bytes

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 bytes

l`d

4, 3 bytes

l`b
eCN

5, 4 bytes

hl`b
telG

6, 3 bytes

elG

7,4 bytes

tttT
helG

8, 3 bytes

ttT

9, 2 bytes

tT

10, 1 byte

T

42, 4 bytes

yhyT

Tudo isso envolve duplo básico (y comandos ), +1 ( h) e -1 ( t) ou l(comprimento de uma string). A variável Z é inicializada em zero.

Para 5, bé inicializado com um caractere de nova linha. Backtick fornece "\n"(incluindo as aspas, e o comprimento dessa sequência é 4.

Experimente aqui !


O usuário Mimarik sugeriu salvar um byte em 42 com yhyT. ( Rejeitei a edição de acordo com meta.codegolf.stackexchange.com/questions/1615/… )
Martin Ender
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.