Encontre o programa que imprime essa sequência inteira (thread da polícia)

39

Este é o tópico dos policiais. O fio dos ladrões vai aqui .

O último tópico de já foi há 4 meses .

A tarefa do policial

  • A tarefa do policial é escrever um programa / função que pega um número inteiro positivo (ou não negativo) e gera / retorna outro número inteiro.
  • O policial deve indicá-lo se o programa for intolerante em relação a zero.
  • O policial fornecerá pelo menos 2 entradas / saídas de amostra.
  • Por exemplo, se eu decidisse escrever a sequência de Fibonacci , escreveria isso na minha resposta:
a (0) retorna 0
a (3) retorna 2
  • O número de exemplos fica a critério do policial.
  • No entanto, a sequência deve realmente existir na Enciclopédia On-line de Sequências Inteiras® , portanto, nenhum gerador de números pseudo-aleatórios para você.:(
  • O policial pode ocultar quantos caracteres desejar.
  • Por exemplo, se meu programa for:

function a(n)
    if n>2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

  • Então eu ocultaria esses caracteres como eu quero:

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

A tarefa do ladrão

  • é obviamente encontrar o código fonte original.
  • No entanto, qualquer código-fonte proposto que produz o mesmo conjunto de saída também conta como válido, desde que também seja encontrado no OEIS.

Dicas para a polícia

  • A função de pesquisa no OEIS funciona apenas por termos consecutivos; portanto, se você deseja ocultar sua sequência, deixe um buraco em qualquer lugar.
  • Aparentemente, não há como ocultar a sequência. Lembre-se disso quando escolher a sequência.

Sua pontuação é o número de bytes no seu código.

O vencedor será a finalização com a pontuação mais baixa que não tenha sido quebrada em 7 dias.

Somente envios publicados em abril de 2016 são elegíveis para a vitória. Os envios publicados posteriormente são bem-vindos, mas não podem vencer.

Para reivindicar a vitória, você precisa revelar o código completo e a sequência OEIS (após 7 dias).

Sua postagem deve ter o seguinte formato (NN é o número de caracteres):


Lua, 98 bytes

Saída:

a(0) returns 0
a(3) returns 2

Código ( #marca caracteres não revelados):

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

Se o código estiver quebrado, insira [Cracked](link to cracker)no cabeçalho. Se o envio for seguro, insira "Seguro" no cabeçalho e revele o código completo em sua resposta. Somente respostas que revelaram o código completo serão elegíveis para a vitória.

Freira Furada
fonte
2
Além disso, busca OEIS pode ter espaços em branco com _, fyi
SP3000
9
Pode ser tarde demais para mudar, mas permitir seqüências que sejam múltiplos de uma sequência OEIS e / ou incluir apenas todos os enésimos termos teria tornado esse desafio muito melhor. sandbox, dica, dica #
Nathan Merrill
6
Posso, por exemplo, escolher a sequência de Fibonacci e fornecer apenas a(1000)? (que é parte da sequência, mas demasiado grande para ser pesquisado em OEIS)
SP3000
2
Eu diria que os valores precisam realmente ser pesquisáveis ​​no OEIS, para que possa ser facilmente verificado que os valores estão corretos para a sequência escolhida.
Mego
3
"Intolerante em relação a zero" não faz sentido. O que isto quer dizer?
usar o seguinte código

Respostas:

11

Vim, 36 pressionamentos de tecla - Seguro!

i****<esc>:let @q="^*i****$**@***"<cr><n>@qbD

(Nota: <n>é onde você digita sua entrada)

Aqui está o código não relacionado à geração de números:

          :let @q="              "<cr><n>@qbD

Ou seja, estou revelando 5 dos 19 caracteres.

<n>é a entrada. Aqui estão alguns exemplos de saídas:

1@q:    1
2@q:    3
6@q:    18

Responda

Esse código imprime os números de Lucas ( A000032 ), que são exatamente como The Fibonnaci Sequence, exceto que ele inicia em 2, 1vez de 1, 1. Aqui estão os 15 primeiros números:

2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843

Aqui está o código revelado:

i2 1 <esc>:let @q="^diwwyw$pb@-<c-v><c-a>"<cr><n>@qbD

Explicação:

i2 1 <esc>                          "Insert the starting numbers
          :let @q="....."<cr>       "Define the macro 'Q'

Explicação da macro:

^                      "Move to the first non-whitespace character on the line.
 diw                   "(d)elete (i)nner (w)ord. This is different then 'dw' because it doesn't grab the space. 
                      "It also throws people off since 'i' is usually used for inserting text.
    wyw$               "Move to the next number, yank it then move to the end of the line 
        pb             "(p)aste the yanked text and move (b)ack
          @-     <c-a> "@- is the register holding the word we deleted. Increment the current number that many times.
            <c-v>      "Since we're adding <c-a> this from the command line, we need to type it as a literal.

Agora, só precisamos remover o segundo número, pois o primeiro número é o número de lucas que queremos. Então nós fazemos

b   "move (b)ack
 D  "(D)elete to the end of the line.

Além disso, se não me engano, este é o primeiro envio seguro! Isso é legal.

DJMcMayhem
fonte
Eu sei a sequência, eu acho. Só não sei como transformá-lo em pressionamentos de tecla do Vim.
9306 Nic Hartley
A saída é apenas o número ou a linha inteira?
ASCIIThenANSI
@ASCIIThenANSI Depois de clicar bDno final, a saída é apenas o número e alguns espaços em branco extras.
DJMcMayhem
Eu entendi a sequência!
Nic Hartley
8

05AB1E , 5 bytes, seguro

Última de hoje: p. Saída:

a(0) = 9
a(5) = 4
a(10) = 89

Código:

___m_

Caracteres ofuscados são indicados com _. Experimente online! -ligação. Usa a codificação CP-1252 .


Solução:

žhžm‡

Explicação:

žh       # Short for [0-9].
  žm     # Short for [9-0].
    ‡    # Translate.

Experimente online! ou Tente para todos os casos de teste! .

Adnan
fonte
Eu conheço a sequência, mas não como gerá-la em tão poucos bytes ... #
7897
@ LegionMammal978 Sim, acho que essa será a parte mais difícil.
Adnan
Posso obtê-lo em 5 bytes com g°<¹-mas não consigo descobrir nenhuma maneira de usar mneste tamanho! D:
user81655
@ user81655 Sim, essa foi a solução alternativa :).
11116 Adnan
6

Elemento , 7 bytes, quebrado

Saída:

a(3) = 111
a(7) = 1111111

Os #caracteres são ocultos e todos são ASCII imprimíveis. Eu acho que este é realmente razoavelmente difícil (por ter apenas 5 caracteres ausentes).

###,##}

Por conveniência, aqui estão as páginas wiki do Try It Online e Esolang .


Meu programa original era:

_'[,$ ` }

O truque é que

]e }são funcionalmente idênticos (ambos são traduzidos }em Perl). Além disso, eu costumava ,$produzir um 1como uma camada adicional de confusão, embora seja possível ignorar ,completamente fazendo isso ,1.

PhiNotPi
fonte
(Eu sei que não devo perguntar isso, mas) você tem certeza de que está correto? Em particular, em }vez de ]?
Leaky Nun
@KennyLau The } está correto, e meu programa (tanto quanto eu sei) funciona em todas as versões do Element.
PhiNotPi
Rachado.
Leak Nun #
Eu acho que a formatação está errada no seu código original?
Rɪᴋᴇʀ
@EasterlyIrk It is. Se você sabe como consertar, fique à vontade.
PhiNotPi
5

Jolf , 5 bytes, quebrado

Saída:

a(2) = 8
a(10) = 4738245926336

Tudo isso é crucial, e eu mostrei 1 de 5.

####x

Código original:

mPm$x
mP     cube
  m$   catalan number
    x  input

Experimente online!

Conor O'Brien
fonte
Rachado!
Leak Nun #
1
Para quem estiver interessado, é esta seqüência: oeis.org/A033536
Azul
5

JavaScript (ES7), 10 bytes, Cracked

Saída

f(0) -> 1
f(1) -> -1

Código

t=>~t##**#

Teste no Firefox todas as noites.O código é uma função anônima. Provavelmente será fácil, pois há apenas três caracteres ocultos, mas pelo menos é curto! : P


Meu código original era:

t=>~top**t

mas depois de forçar brutalmente meu próprio código para uma solução, logo percebi

t=>~t.x**t (Onde x pode haver qualquer caractere de nome de variável)

também pode ser usado. Isso funciona porque

nas especificações originais do operador de exponenciação do ES7, o operador tinha uma precedência menor do que os operadores unários (ao contrário da matemática convencional e da maioria dos outros idiomas). ~executa um NOT bit a bit em t.x( undefined) ou top( Object) que os converte em um número inteiro assinado de 32 bits (não podem ser convertidos como esses 0) antes de executar o NOT (assim 0se torna -1). Analisei mais a fundo e, recentemente, a especificação mudou para não permitir referências ambíguas como essa (não é bom para o futuro golfe D:), no entanto, a maioria dos motores ES7 ainda não atualizou a versão mais recente da especificação.

user81655
fonte
1
@insertusernamehere Parece que ele contém uma expressão ilegal. Porém, ele funciona no Firefox todas as noites. Eu acho que eles implementam a especificação ES7 de maneira diferente.
user81655
Acabei de adquirir o Firefox todas as noites e devo reclamar que isso não funciona lá. Janelas de 32 bits a partir daqui
Conor O'Brien
Supondo que **seja equivalente a Math.pow, eu fiz alguns dos meus próprios testes e até tenho uma força bruta. Isso é muito difícil de decifrar!
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ O meu Firefox todas as noites está atualizado a partir de ontem. Estou usando o OS X, mas tenho certeza de que também funcionará no Windows. O Traceur com as opções apropriadas do ES7 ativadas também o transpila corretamente.
user81655
@ CᴏɴᴏʀO'Bʀɪᴇɴ Tentei no Windows de 32 bits a partir do seu link e também funciona. Estou surpreso que sua busca por força bruta não possa decifrá-la. Na verdade, acabei de perceber que há muitas soluções para isso! D:
user81655
4

05AB1E, 4 bytes ( Cracked )

Saída de amostra:

a(5) = 51
a(8) = 257

E para o código:

###^

Eu revelei o último. Deve ser fácil, porém, tive muita dificuldade em encontrar uma sequência :(

Todos os caracteres ocultos são imprimíveis.

Paul Picard
fonte
1
Rachado! :)
Adnan
4

MATL , 5 bytes, quebrado

Caracteres ocultos são indicados por %.

%5%*%

Saída:

a(1) = 3
a(2) = 6
a(4) = 12

A entrada 0é válida.


Código original:

35B*s

isso é,

35    % push number 35
B     % convert to binary: array [1 0 0 0 1 1]
*     % multiply element-wise by implicit input n: gives [n 0 0 0 n n]
s     % sum of array: gives 3*n
Luis Mendo
fonte
2
Hmmm, os cinco no código são muito irritantes!
9116 Adnan
Tecnicamente, isso poderia ser brutalmente forçado por um programa ... mas não vou fazer isso.
Leaky Nun
1
rachado
flawr
4

SWIFT, 55 bytes, Rachado

func M(n:Int)->Int{
return(n*****) ?M(**n****):n***;
}

* marca um caractere oculto

Saída:

M(30) -> 91
M(60) -> 91
M(90) -> 91
M(120)-> 110
M(150)-> 140

Função aceita 0

Nefrin
fonte
1
Cracked
Emigna
4

Ruby, 46 bytes, seguro

Editar para adicionar isenção de responsabilidade / desculpas: Esta sequência começa com f [0], enquanto a entrada OEIS começa com f [1]. Os valores são os mesmos.

Código ofuscado ( #qualquer caractere):

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}

Ligue como

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}[3] (returns 39)

Saída:

f[0] = 0
f[1] = 3
f[2] = 12
f[3] = 39
f[4] = 120
f[5] = 363
f[6] = 1092
f[7] = 3279
f[8] = 9840
f[9] = 29523

Solução:

f=->*x{for x[-1]in(0..x[0]);x*=3;end;x.inject:+}

Seqüência:

http://oeis.org/A029858

Explicação:

O truque menor aqui é que declaramos o parâmetro como *xmelhor que x. Isso significa que, se você entrar 2, xserá definido como [2]... primeiro. O principal truque explora a sintaxe Ruby bizarra e justamente obscura, na qual é possível definir o iterador em um loop for para qualquer lado esquerdo válido de uma expressão de atribuição, em vez de uma variável iteradora como i. Portanto, isso passa de 0 a (neste exemplo) 2, atribuindo cada número a x[-1], o que significa que substitui o último valor de x. Em seguida, o corpo do loop x*=3muda ainda mais x ao concatená-lo para si mesmo 3 vezes. Então, primeiro x se torna [0], então [0,0,0]. No próximo loop, torna-se [0,0,1]então [0,0,1,0,0,1,0,0,1]. Finalmente passamos em 2 e torna-se [0,0,1,0,0,1,0,0,2], então[0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2] . Em seguida, somamos o resultado usando oinject método, que reduz a matriz aplicando +(o método passado) a cada elemento por vez. Se considerarmos como cada iteração altera a soma, veremos que adicionamos efetivamente 1 (substituindo o último elemento por um elemento um mais alto) e multiplicamos por 3. Como 3*(n+1) = 3*n + 3isso implementa a relação de recorrência de Alexandre Wajnberg para a sequência, conforme descrito no página.

histocrata
fonte
Eu realmente gosto dos seus policiais aqui, este em particular. Bem feito.
Não que Charles
3

Hexagonia , 7 bytes, rachada

Saída:

a(1) = 2
a(2) = 4

Código oculto:

?#####@

Ou alternativamente:

 ? #
# # #
 # @

Experimente online pode ser útil.

Adnan
fonte
Rachado.
Martin Ender
Uhhh espera, seu código funciona para entrada 0?
Martin Ender
@ MartinBüttner Oh, não, meu mal. Sua solução foi a certa.
9116 Adnan
3

PHP, 41 bytes, quebrado

Sim, finalmente outro desafio de Policiais e Ladrões. Espero não ter facilitado as coisas.

Saída

a(5)   = 0
a(15)  = 1
a(35)  = 0
a(36)  = 1
a(45)  = 1

Fonte

____________________$argv[1]____________;
####################        ############

Notas


Rachado

Obviamente, facilitei e não forneci exemplos suficientes. A sequência que eu tinha em mente era A010054 :

a (n) = 1 se n for um número triangular mais 0.

Aqui está o meu código fonte original:

echo(int)($r=sqrt(8*$argv[1]+1))==$r?1:0;

Ele testa se a entrada é um número triangular e gera 1ou não 0.

insertusernamehere
fonte
Rachado.
LegionMammal978
3

Jolf, 11 bytes, Rachado , A011551

c*______x__

c*mf^+91x~P

Código original:

c*^c"10"x~P

Exemplos:

0 -> 1

12 -> 1618033988749
Rɪᴋᴇʀ
fonte
Rachado .
Adnan
@ Adnan Bom trabalho, embora diferente do meu. E você não conseguiu descobrir a primeira operação. : P
Rɪᴋᴇʀ 09/04/19
Sim, eu não conseguia descobrir o que ele faz: p
Adnan
@Adnan foi um elenco para a função int, mal utilizado como um andar.
Rɪᴋᴇʀ
3

MATL, 9 bytes, Rachado

Código:

3#2###*##

Saída:

a(1)  = 3
a(2)  = 6
a(4)  = 12
a(12) = 37

a(0) é válido.


Rachado

Sequência original: A059563

Código original:

3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor
taça
fonte
Rachado .
Adnan
3

Java, 479 bytes, Rachado

Saídas:

a(10) = 81
a(20) = 35890

(As entradas são fornecidas por meio de argumentos de linha de comando)

Código ( #marca caracteres ocultos):

import java.util.*;
public class A{

    public static int#########
    public boolean###########

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ################if(##>##{
            ###########d#
            #######+##p##########+##########(#######
        }

        System.out.println(#########################
            ###(A.#############(#5#####)));
    }
}

O programa inicia no índice 0.

(Observe que o SE substitui todos os \trecuos por 4 espaços, elevando o total de bytes para 569. Clique aqui para ver o programa com\t recuos em vez de recuos de espaço.)

Código original:

import java.util.*;
public class A{
    public static interface B{
    public boolean C(int i);} 

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<input; ix++)cif(i->  {
            return l.add(
            l.pop()+l.peekFirst()+l.peekLast());});{    
        }

        System.out.println(l.get(1));}static boolean 
            cif(A.B b5){return (b5.C((0)));
    }
}

(Mesmo código, mas formatado normalmente):

import java.util.*;

public class A {
    public static interface B { //functional interface for lambda expression
        public boolean C(int i); //void would have given it away
    }

    static A a = new A(); //distraction

    public static void main(String[] args) {
        int input = Integer.parseInt(args[0]);//Input

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);//Set up list
        l.add(0);
        l.add(0);

        for (int ix = 0; ix < input; ix++)
            cif(i -> { //Fake if statement is really a lambda expression
                return l.add(l.pop() + l.peekFirst() + l.peekLast());
            });
        { //Distraction
        }

        System.out.println(l.get(1));//Output
    }

    static boolean cif(A.B b5) { //Used to pass in lambda expression.
                  //The A. and b5 were both distractions
        return (b5.C((0)));
    }
}
Daniel M.
fonte
Hum, como você chega a uma contagem de 488 bytes? Conto 545 de iaté }? E especifique tolerância 0.
Vampiro
Não são seus exemplos a(9)e a(19)ou a(8)e a(18), de acordo com qual versão do OEIS você tirou?
Vampiro
@ BjörnKautler Vou postar um link no contador de bytes quando chegar em casa. O que você quer dizer com tolerância 0? O primeiro valor é um (1) = 0
Daniel M.
No OP: "A tarefa do policial é escrever um programa / função que pega um número inteiro positivo (ou não negativo) e gera / retorna outro número inteiro. O policial deve indicá-lo se o programa for intolerante em relação a zero". Então, acho que você considera a entrada 1 como 0 e isso também explica a mudança de posição, de acordo com a sequência OEIS.
Vampiro
@ BjörnKautler OK, obrigado. O programa não falha se for inserido 0, mas a sequência começa no índice 1, então acho que é intolerante a zero.
Daniel M.
3

Oitava, 34 bytes, quebrada

@(m)(m###m#####m##)&isprime(#)####

Saídas:

ans(1) = 0
ans(6) = 5
ans(7) = 10
ans(8) = 15

A sequência começa ans(1)em OEIS.

Stewie Griffin
fonte
Rachado.
precisa saber é
3

C, 71 bytes rachados

############
#####
main(){
 scanf("%d",##);
 ###6#;
 printf("%d",##);
}

Saída:

a(1) = 0   a(2) = 0   a(5) = 1
a(6) = 1   a(7) = 1   a(9) = 2

Isso funciona com o gcc e é um programa completo. Aceita 0 como entrada.

mIllIbyte
fonte
Rachado.
feersum
Bem, eu deveria ter revelado mais personagens. Postei um diferente e tentei evitar chamadas de função. codegolf.stackexchange.com/a/77583/52554
mIllIbyte
3

Pitão, 70 bytes, Rachado

DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ

# são os caracteres ocultos

Foi quebrado, então aqui está a versão sem caracteres ocultos:

DhbI|qb"4"qb"0"R!1Iqb"1"R!0Rh+""sm^sd2cb1;W<lY+Q1Ih+""Z=Y+YZ)=Z+Z1;@YQ

Saídas de amostra:

a(2) -> 10
a(4) -> 19

Boa sorte para encontrar isso no OEIS, pessoalmente não consegui encontrá-lo nesses exemplos (mesmo que a sequência seja bastante fácil de identificar).

FliiFe
fonte
Rachado .
Adnan
3

Ruby, 38 bytes, quebrado

Código ofuscado ( #pode ser qualquer caractere):

->#{(s=#########).sum==#3333&&eval(s)}

Saída:

Multiplica a entrada por 10 (A008592). Funciona para qualquer número inteiro, incluindo 0. por exemplo

->#{(s=#########).sum==#3333&&eval(s)}[3]  => 30
->#{(s=#########).sum==#3333&&eval(s)}[10] => 100
histocrata
fonte
Rachado.
xsot
3

05AB1E , 5 bytes, quebrado

Saída:

a(0) = 0
a(1) = 0
a(2) = 1
a(3) = 1
a(4) = 1
a(5) = 1
a(6) = 1
a(7) = 1
a(8) = 1
a(9) = 1
a(10) = 0
a(11) = 0

Código ofuscado:

_____

Experimente online! -ligação.

Adnan
fonte
1
Rachado.
precisa saber é o seguinte
3

05AB1E , 4 bytes, quebrado

Bem, então, eu acho que sou viciado em CnR's ... Código ofuscado ( _indica um curinga):

____

Seqüência:

a(1) = 2
a(4) = 6720

A sequência no OEIS começa em (1) = 2.

Experimente online! -ligação

Adnan
fonte
Cracked
David
3

Lua, 45 Bytes, Rachado

Uma pequena dica:

a(0) will make the program crash :)

Saída

a(1)=>0
a(2)=>1

Código

Usa #para ocultar o código :).

a=function(n)#####n###### and #or ########end

Eu estava usando o OEIS A007814 , com o seguinte código:

a=function(n)return n%2>0 and 0or 1+a(n/2)end
Katenkyo
fonte
Rachado .
Leaky Nun #
@KennyLau Bem feito, eu adicionei o OEIS estava pensando eo código destina-se, eu deveria ter acrescentado pelo menos mais uma saída para evitar que isso aconteça: p
Katenkyo
3

Pyke , 15 bytes, SEGURO

Saída

a(2) = 21
a(15) = 17

Código revelado:

#R#D######+##)#

Solução:

OEIS A038822
wR}DSR_Q*L+#P)l
Usei alguns arenques vermelhos aqui wR}para gerar o número 100 e revelar o caractere Rque normalmente é usado para girar a pilha. Eu também usei, em #P)lvez do mais simples, mPspara contar o número de números primos na sequência.

Azul
fonte
A sequência em questão começa a partir de n = não 1 n = 0 pelo caminho
Azul
Eu pensei que era essa sequência, exceto que começa em n = 0 e não n = 1, como você afirmou.
Emigna
3

C, 82 bytes, seguro

####=############
main(i){scanf("%d",##);
for(i=1;i++/4<#;)##=2;
printf("%d",##);}

Funciona com o gcc e é um programa completo, que lê sua entrada de stdin e imprime sua saída em stdout. Aqui a sequência é A004526, piso (n / 2) .

a(0) = 0    a(1) = 0    a(2) = 1
a(3) = 1    a(4) = 2    a(5) = 2
a(6) = 3    a(7) = 3    a(8) = 4

Solução:

a;*b=(char*)&a+1;
main(i){scanf("%d",&a);
for(i=1;i++/4<2;)a*=2;
printf("%d",*b);}

Isso funciona apenas em pequenas máquinas endian e apenas se o tamanho de char1 byte.
E somente se o byte mais alto que o byte de ordem mais alta ativer valor 0. Acho que isso é verdade para o gcc, pois, por padrão, variáveis ​​globais não inicializadas entram no segmento bss e variáveis ​​globais inicializadas entram no segmento de dados (consulte https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).
Portanto, apenas aentra em bss (a única outra variável global bé inicializada e, portanto, entra no segmento de dados). Se anão estiver no final de bss, o byte superior ao byte de ordem mais alta atambém estará em bss e, portanto, terá o valor 0.

mIllIbyte
fonte
Tente fazer chamadas de função agora :)
mIllIbyte 11/16
1
Eu não acho que você tinha que especificar a sequência ...
FliiFe
@FliiFe - Fixed :)
mIllIbyte
3

05AB1E, 1 byte, Rachado

_

_ denota código oculto.

f(1) == 1
f(18) == 6
penalosa
fonte
Cracked
Emigna
2

Elemento , 10 bytes, quebrado

Saída:

a(3) = 6561
a(4) = 4294967296

Provavelmente, existem apenas algumas maneiras de calcular essa sequência no Element. Encontrei uma solução de 9 caracteres, mas achei que essa solução de 10 caracteres é realmente mais difícil. o# são caracteres ocultos.

#_####@^#`

Por conveniência, aqui está o wiki do Try It Online e do Esolangpáginas .


O original era

2_3:~2@^^`
PhiNotPi
fonte
Mostre mais um byte.
Leaky Nun #
@KennyLau eu pensei que era 1 de 5? É 10 bytes e eu estou mostrando 3.
PhiNotPi
Entradas e saídas não contam, por isso você tem 8 bytes e você mostrou 1.
Leaky Nun
@KennyLau done.
PhiNotPi
Rachado.
Leak Nun # 15
2

Pyth , 18 bytes

# marca caracteres não revelados.

L?Jtb##5#m##S#2 #y

Saídas (começa em 1 ):

1 -> 2
2 -> 3
3 -> 5
4 -> 7

Intérprete online

Freira Furada
fonte
Primes, não? Se não ...
Azul
Se não ... o que?
Leaky Nun
então eu não tenho idéia
Azul
2

05AB1E , 5 bytes, quebrado

Espero que este envio não seja tão fácil quanto os meus outros: p. Saídas:

a(0) = 0
a(1) = 1
a(2) = 6
a(3) = 24
a(4) = 80
a(5) = 240

Código ofuscado:

####O

Contém alguns caracteres não ASCII, porém, usa o CP-1252 codificação .

Experimente online! pode ser útil: p.

Adnan
fonte
Rachado.
LegionMammal978
Por que sinto que já vi isso antes?
Leak Nun #
@KennyLau ¯ \ _ (ツ) _ / ¯
Adnan
2

Jolf , 11 bytes, Rachado .

Saída:

a(10) = 4
a(20) = 6
a(30) = 8

E o código parcialmente oculto:

####xd###x#

Dica:

Quando examinei as seqüências em ordem, não fui muito longe antes de encontrar esta.

A versão crackeada não é exatamente igual ao meu código original. Atualmente, não estou no meu computador, então não o tenho exatamente, mas era algo assim:

l fzxd!m%xH

(A única parte da qual não tenho certeza é a !m. É o que verifica se uma variável é zero.)

Nic Hartley
fonte
Eu encontrei a seqüência ... Pena que eu não sei Jolf ou javascript muito bem :(
Azul
@muddyfish, Same here ...
LegionMammal978:
Bem, acho que é hora do mestre fazer ... posso?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Se todo mundo está perplexo - e parece que está - fique à vontade.
9306 Nic Hartley
Rachado .
Conor O'Brien
2

Pyke , 6 bytes, Rachado

###X#s

Saída:

a(2) = 8
a(8) = 80
a(10) = 120

Isso não funciona com N <1

Solução original:

hSmX$s

Azul
fonte
Welp, eu encontrei uma alternativa mais fácil para o que eu tinha
Azul
Rachado.
LegionMammal978