Sua tarefa, se você deseja aceitá-la, é escrever um programa que produza um número inteiro positivo (maior que 0). Se o código fonte for duplicado, a saída deve permanecer a mesma. A parte complicada é que, se o código fonte for digitado três vezes (triplicado?), A saída será multiplicada por 3.

Regras

• Você deve criar um programa completo . Ou seja, sua saída deve ser impressa em STDOUT.

• A fonte inicial deve ter pelo menos 1 byte de comprimento.

• Ambos os números inteiros devem estar na base 10 (é proibido produzi-los em qualquer outra base ou com notação científica).

• Seu programa não deve receber entrada (ou ter uma entrada vazia não utilizada).

• É permitida a saída de números inteiros com espaços à direita / à direita.

• Os zeros à esquerda são permitidos apenas se o número de dígitos for consistente, por exemplo: 001 - 001 - 003 ou 004 - 004 - 012

• Você não pode assumir uma nova linha entre cópias da sua fonte.

• Isso é código-golfe , então o código mais curto (original) em cada idioma vence!

• Aplicam-se lacunas padrão .

Exemplo

Digamos que seu código fonte seja Abce sua saída correspondente seja 4. Se eu escrever AbcAbce executá-lo, a saída ainda deve ser 4. No entanto, se eu escrever AbcAbcAbce executá-lo, a saída deve ser 12.

Roubado descaradamente Derivado do desafio do Sr. Xcoder

Wumpus , 6 bytes

{~)
@O

Experimente online!
Experimente dobrou!
Experimente triplicou!

Imprime 1e 3.

Explicação

Encontrei uma tonelada de soluções de 6 bytes por pesquisa de força bruta, mas nenhuma por 5 bytes. Isso não significa necessariamente que não existem 5 bytes, mas eles provavelmente usariam caracteres estranhos ou algo assim.

Acabei escolhendo esta solução porque ela não imprime nenhum zeros à esquerda (a maioria deles faz) e possui algum fluxo de controle interessante. Vamos começar com o programa único:

Portanto, o código executado é:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

Bastante fácil. Agora, o programa duplicado. Como a primeira linha é anexada à segunda linha, a grade se estende à largura 5 (e altura 3), o que altera significativamente o fluxo de controle:

O IP percorre esse loop exatamente uma vez, então o código executado é:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

Finalmente, o programa triplicado é bastante semelhante ao duplicado, mas temos alguns comandos mais importantes nessa terceira linha:

Portanto, o código executado é:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

Casca , 5 bytes

KΣK+1

Experimente online!

Repetido duas vezes!

Repetido três vezes!

Explicação

É muito difícil construir um programa repetível no Husk. Como o sistema de tipos proíbe uma função que possa ser aplicada a si próprio, tenho que, de alguma forma, permitir que a primeira parte avalie uma função e o restante avalie um valor, e os tipos de built-ins existentes são projetados para evitar isso. tipo de ambiguidade. Os tokens do programa são

• K, que constrói uma função constante. K a bé equivalente a a.
• Σ, Que leva um número inteiro n e retorna a n th número triangular.
• +, que adiciona dois números.
• 1, que é o literal 1.

O programa original é interpretado assim:

   K Σ (K+) 1
== Σ 1
== 1

A (K+)é uma função sem sentido que é comida pela primeira K.

O programa repetido duas vezes é interpretado da seguinte maneira:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

A função entre parênteses é novamente consumida pela primeira K.

O programa repetido três vezes é interpretado da seguinte maneira:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

Geléia , 7 5 bytes

»‘µ*Ḃ

Experimente online!

Experimente dobrou!

Experimente triplicou!

Como funciona

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell , 24 bytes

main=print.div 3$4
 -1--

Impressões 1: Experimente online!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Também imprime 1: Experimente online!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Impressões 3: Experimente online!

Cubix , 5 bytes

)<@OP

Experimente online: uma vez , duas vezes , três vezes .

Explicação

Cubix é uma linguagem baseada em pilha cujas instruções são colocadas ao redor da parte externa de um cubo. Importante notar é que a pilha é inicialmente preenchida com zeros infinitos, o que nos permite "extrair valores do nada" com os operadores, em vez de empurrá-los explicitamente.

Devo admitir que isso foi encontrado por um brutador; Eu nunca teria encontrado isso sozinho. De fato, @MartinEnder foi quem me pediu para tentar forçar brutos, pois estava procurando essa solução sem sorte. Essa é a única solução que o bruto encontrou, e acredito que seja a única solução mais curta do Cubix.

Programa único

Assista correr!

O programa original cabe em um cubo de unidade. Aqui está a rede desdobrada:

  )
< @ O P
  .

O IP (ponteiro de instrução) inicia na face mais à esquerda (a <) na direção leste. O <imediatamente aponta para o oeste e envolve o P. Pé exponenciação e, como não há nada na pilha, o intérprete obtém dois 0 se calcula 0 ⁰ , que é 1 de acordo com o JavaScript. Odepois imprime esse valor e @termina o programa.

Programa duplo

Assista correr!

)<@OP)<@OP

O programa de 10 bytes é muito longo para caber em um cubo de unidade e, portanto, é expandido para um cubo de tamanho 2:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

Como antes, o IP começa no canto superior esquerdo da face mais à esquerda. Desta vez, a primeira instrução é P, que empurra um 1 como antes. A seguir ), incrementa o item superior, transformando-o em um 2 . Em seguida, <vira o IP e ele atinge )novamente, transformando o 2 em um 3 .

Aqui é onde fica interessante. Paumenta o segundo item do topo ao poder do primeiro item, que fornece 0 ³ = 0 . Em seguida, o IP passa para a face mais à direita e passa por dois no-ops .antes de atingir outro P. Aqui vemos outra peculiaridade do Cubix: operadores binários (como P) não removem seus operandos da pilha. Portanto, como a pilha está agora [3, 0], calculamos 3 ⁰ = 1 , que Ogera e @finaliza o programa.

Programa triplo

Assista correr!

)<@OP)<@OP)<@OP

Como no programa duplo, o triplo pode caber em um cubo tamanho 2:

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

Este programa inicia da mesma maneira que o anterior: Pempurra 1 , )incrementa, <aponta o IP oeste, )incrementa novamente e Pagora empurra 0 . O IP é então enrolado <na face mais à direita, o que não faz nada, pois o IP já está apontado para o oeste.

Aqui está a única diferença do programa duplo: o )incrementa o 0 no topo da pilha para 1 . Quando Pexecuta sua mágica novamente, desta vez calcula 3 ¹ = 3 . Oproduz e @termina, e provamos conclusivamente que a terceira vez é de fato o charme.

Flak cerebral , 10 bytes

<>([]{}())

Experimente online!

Experimente dobrou!

Experimente triplicou!

Explicação:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Quando executamos isso uma vez, ele será colocado (0 + 0 + 1) == 1na pilha alternativa. Executou uma segunda vez, coloca o mesmo na pilha principal. Executar uma terceira vez, no entanto, ele avalia (1 + 1 + 1) == 3e envia isso para a pilha alternativa e imprime implicitamente.

SQL, 25 24 23 bytes

( -1 Byte Removido um caráter digitado incorretamente que sempre foi comentado e não fazer nada )
( -1 Byte Mudou SELECTa PRINTcomo recomendado por Razvan Socol )

PRINT 2/*
*2+1--*/-1
--

Como funciona:
no SQL, você pode comentar as tags de comentário, assim:

/*
'Comment'--*/

vs

--/*
'Not Comment'--*/

Código em 1 linha com comentários excluídos:
Primeira iteração: SELECT 2-1Saída: 1
Segunda iteração: SELECT 2-1*2+1Saída: 1
Terceira iteração: SELECT 2-1*2+1*2+1Saída:3

SOGL V0.12 , 7 5 4 bytes

ē»«I

Experimente aqui!

Experimente dobrou!

Experimente triplicou!

Explicação:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E , 6 5 bytes

.gDÈ+

Experimente online! ou Tente dobrar! ou tente triplicar!

Explicação

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

Individual: 0 + (0 % 2 == 0) -> 1
Duplo: 1 + (1 % 2 == 0) -> 1
Triplo:2 + (2 % 2 == 0) -> 3

> <> , 9 bytes

\5 n;
\\1

Experimente online!

Experimente dobrou!

Experimente triplicou!

Achei isso por sorte, usando a filosofia de que "se você fizer o caminho do peixe complicado o suficiente, eventualmente algo funcionará". As versões original e duplicada imprimem um 5, e a versão tripla imprime 1 e 5 para produzir 15 = 3 × 5. Aqui estão as versões multiplicadas, para sua leitura:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2 ,  46 45  39 bytes

Inspirado pela resposta de Halvard . Fico feliz que meu desafio tenha inspirado um novo, o que acho ainda mais interessante. Guardado 6 bytes graças a Kevin Cruijssen .

print open(__file__,"a").tell()/79*3|1#

Experimente online!

Experimente dobrou!

Experimente triplicou!

Como funciona (desatualizado)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

Quando é dobrado, o comprimento se torna 90 , mas o novo código é ignorado graças ao #, então é k==90avaliado como True. Booleanos são subclasses de números inteiros em Python, então k>>Trueé equivalente a k>>1, que é essencialmente k / 2 = 45 . Quando é triplicou, o novo código é novamente ignorado, portanto, o novo comprimento é de 135 , o que não se mudou porque k==90avalia a False, então k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k, e k é impresso tal como está.

Python 2 , 36 bytes

Essa foi uma sugestão de Aidan F. Pierce, com 38 bytes, e eu a joguei com 2 bytes. Não estou publicando isso como minha principal solução, porque não o criei sozinho.

0and""
True+=1
print True>3and 3or 1

Experimente online! Experimente dobrou! Experimente triplicou!

R , 37 31 28 bytes

Obrigado a Giuseppe por jogar fora os 3 bytes finais.

length(readLines())%/%2*2+1

(com uma nova linha à direita).

Experimente uma vez!

Experimente duas vezes!

Experimente três vezes!

Isso usa o readLines()truque da resposta de Giuseppe ao desafio de 8 bolas , onde é stdinredirecionado para o arquivo de origem. Este código basicamente conta quantas linhas existem abaixo da primeira linha e produz 1se houver 1 ou 3 linhas (ou seja, o código é único ou duplicado), ou 3se houver 5 linhas (ou seja, o código é triplicado).

Perdido , 38 bytes

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Experimente online!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Experimente online!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Experimente online!

Explicação

Lost é uma linguagem muito interessante para esse desafio. A técnica usual de Lost é construir uma "armadilha". Uma armadilha é uma seção do programa projetada para capturar todos os ips em um único local, de modo que suas pilhas possam ser limpas e controladas para seguir uma direção específica. Isso torna os programas de gravação em Lost muito mais gerenciáveis. No entanto, como o programa é duplicado, também precisamos evitar a duplicação de armadilhas. Isso exige que projetemos uma nova armadilha que funcione corretamente, mas quando duplicada, apenas uma das armadilhas funciona. Minha idéia básica aqui é a seguinte

v<<<<>
>%?!^^

Enquanto a pilha estiver vazia, ?ele removerá um item e fará com que volte ao início, se esse item for diferente de zero. A chave aqui é que, quando isso empilha a ^^linha s

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

Significando que não importa como você entra, você sempre sai no mesmo local.

A partir daqui, podemos tentar implementar a mesma idéia na minha resposta Klein .

\\<<<<<v<<<<>
2>((1+@>?!^%^

A espinha dorsal do nosso programa é o lado esquerdo que empurra um número de 2s. Cada vez que adicionamos uma cópia do programa, outra 2é adicionada à espinha dorsal do programa, o que significa que outros 2 são enviados à pilha. Depois que sai do fundo, ele salta \\>e executa o código

((1+@

Isso remove os 2 primeiros itens da pilha, adiciona um ao que resta e sai. Uma vez que nosso backbone tenha 3 2s, adicionaremos 1 e obteremos 3, se tivermos menos de 3 itens, apenas descartamos a pilha inteira e retornamos 1.

Agora, o único problema que resta é que o !programa pode causar um loop infinito. Se o ip começar a !subir, ele pulará e pousará de volta onde estava. Isso significa que precisamos adicionar outra linha abaixo para impedir o loop.

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

Isso tem o pequeno problema de colocar algumas barras entre nossos ^s na armadilha. No entanto, milagrosamente, tudo dá certo. Nossos ips se movimentam adequadamente para que não faça diferença.

Stax , 5 bytes

|dhH^

Execute e depure online! · Dobrado · Triplicado

Explicação

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C (gcc) , 95 91 85 bytes

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

Experimente online!

Japonês , 8 6 5 bytes

-1 byte graças a @ETHproductions

°U-v

Explicação:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

Isso avalia como 1-0 = 1

O dobro é avaliado para 2-1 = 1

Triplicado avalia para 3-0 = 3

Pure Bash (nenhum wcou outros utilitários externos), 27

trap echo\ $[a++&2|1] EXIT

• Tente uma vez.
• Tente duas vezes.
• Tente três vezes.

Perl 5 , 18 15 13 12 11 bytes

-3 bytes graças a nwellnhof

say 1|
+.7#

Uma vez Experimente online!

Experimente duas vezes online!

Experimente três vezes online!

> <> , 10 9 8 bytes

562gn|

Experimente online!

Experimente dobrou!

Experimente triplicou!

Tenho certeza de que há uma solução de 8 bytes em algum lugar por aí.

O não imprimível no final possui o valor ASCII 1 e é buscado apenas pelo gcomando et na terceira iteração. Nos dois primeiros, imprime 05e depois imprime 15.

C (gcc) , 107 bytes

Minha primeira submissão em C (gcc). Muito tempo ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

Links TIO: simples , duplos , triplos .

Labirinto , 12 11 9 bytes

: #%! @
 7

TIO (1x) , TIO (2x) , TIO (3x)

JavaScript, 81 77 74 70 bytes

^{Guardado 4 bytes graças a Shaggy}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Solução JS muito ruim. Consome os valores da [3,1,1]matriz da direita ( pop()). Registra um tempo limite para exibir o valor atual no futuro. Se um tempo limite já estiver registrado, cancele-o. Baseia-se na natureza suja de var, que eleva declarações variáveis.

Duas vezes:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Três vezes:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C (gcc) , 53 52 bytes

Observe o espaço depois #endif.

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

Experimente online!

Carvão , 12 bytes

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

Experimente online! Link é um código detalhado.

Experimente dobrou!

Experimente triplicou!

Explicação

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript, 43 40 bytes

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell , 54 48 45 44 bytes

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

Experimente online!

Experimente dobrou!

Experimente triplicou!

Obtém o seu próprio caminho de invocação com $PSCOMMANDPATHe executa uma get- conteúdo no arquivo. Ifa contagem de caracteres desse arquivo é menor que 99(verificado via wc -ccoreutils), então produzimos 1e exit(ou seja, paramos a execução). Isso explica o código original e o código dobrado. Caso contrário, saímos 3e saímos . O código real que está nas seções dobrada ou triplicada não tem sentido, pois ou exitantes de chegarmos a ele, ou está por trás de um comentário #.

Economizou 6 bytes graças a Mr. Xcoder
Economizou 3 4 bytes graças a Pavel

C # (178 bytes)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

solução C # louca, mas estou feliz que seja possível em uma linha em C #. :)

Para mim, a parte mais difícil foi ter C # válido que inicializaria ou incrementaria a mesma variável, então acabei abusando do ConfigurationManager porque precisava de um NameValueCollection estático global e ConfigurationManager estático global e o único que consegui pensar que poderia atualizar na memória. EnvironmentVariables foi outra opção que eu escolhi, mas ele não possui um indexador, portanto não sei como fazer isso em uma linha que pode ser copiada e colada para produzir a saída necessária conforme a especificação.

Encantos Rúnicos , 35 bytes

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

Experimente online!

Trabalhar nesse caso me permitiu encontrar um erro no analisador ao lidar com os novos caracteres do modificador de atraso, embora o resultado final acabe não sendo afetado por ele, pois acabei não precisando deles.

Funções devido ao fato de a linha final não ter uma nova linha à direita (ou, na verdade, espaços à direita), permitindo que os IPs duplicados gerem em um local diferente. O canto superior esquerdo acaba fazendo um loop grande ao redor da grade, enquanto o segundo IP executa uma operação de reflexão para substituir o \na 6ª linha por a . Esse IP, então, fará um loop para sempre e não fará nada.

O terceiro IP também faz essa mesma substituição ao mesmo tempo, mas como está localizado na 13ª linha, sua cópia desse refletor o envia para cima e executa a 1f'3wsequência presente no canto superior direito, que substitui 1por um 3no 14º linha, pouco antes do PI inicial executa-lo, fazendo com que o programa triplicou para saída 3em vez de 1(valores também poderia ser 2e 6, 3e 9, 4e 12, ou 5e 15devido à disponibilidade de a-fconstantes numéricas; 1e 3foram escolhidos arbitrariamente). Em seguida, ele é deixado em um loop sem fim, executando mais comandos de reflexão que não fazem nada.

Experimente em triplicado!

Perl 5, 28 25 bytes

-3 bytes graças a @neil!

print"\e[D$a"if(++$a!=2);

Move o cursor para trás (não faz nada no início da linha) e imprime o valor da $aprimeira e da terceira vez (ou seja, a terceira vez que um 1 é impresso, o cursor se move e um 3 é impresso na posição do 1).

QBasic, 19 bytes

CLS
x=2^x
?x-1OR 1

A fonte deve incluir uma nova linha à direita.

Explicação

Queremos saída 1, 1, 3. Observe que esses números são um a menos que potências de 2. Portanto:

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.