Baseado neste desafio.

No jogo de ritmo osu! , o modificador de dificuldade "Tempo duplo" na verdade só aumenta a velocidade em 50%.

Sua tarefa é escrever um programa que gera um resultado positivo mesmo inteiro (superior a 0), e quando cada byte / personagem (a sua escolha qual) em seu código fonte é duplicado, deve saída o número multiplicado por 1,5.

Por exemplo, se o seu código-fonte é ABCe gera 6, AABBCCdeve gerar 9.

Seguindo as regras do desafio original:

Regras

• Você deve criar um programa completo.
• 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 e não utilizada) e não deve gerar nenhum erro (os avisos do compilador não são considerados erros).
• É permitida a saída de números inteiros com espaços à direita / à direita.
• Você não pode assumir uma nova linha entre cópias da sua fonte.
• Isso é código-golfe , portanto, o menor número de bytes em cada idioma vence!
• Aplicam-se lacunas padrão .

Eu imagino que isso será muito menos trivial do que o desafio original, mas espero que possamos ver algumas respostas criativas e únicas!

Postes , 7 5 4 bytes

Escolheu um idioma aleatório no TIO usou-o

46vt

Explicação:

Experimente Online!

46    # Stack is [4, 6]

v     # Reverse the stack [6, 4]

t     # take top of stack 4

Dobrado:

4466   # Stack is [4, 4, 6, 6]

vv     # Reverse the stack twice so it's the same [4, 4, 6, 6]

tt     # take top of stack 6 and again which is 6 again

Guardado 2 bytes graças a officialaimm

Guardado 1 bytes graças a Veedrac

Geléia , 2 bytes

!‘

Experimente online!

Explicação:

!‘ Implicit 0
!  Factorial
 ‘ Increment

Versão dobrada:

!!‘‘

Experimente online!

Explicação:

!!‘‘ Implicit 0
!    Factorial
 !   Factorial
  ‘  Increment
   ‘ Increment

LibreOffice Calc, 8 bytes

=A2+3
19

Salve-o como *.csve abra-o no LibreOffice Calc. Você terá 22 na A1.

Dobre-os:

==AA22++33

1199

Você terá 33 na A1

MATL , 3 bytes

TnQ

Experimente online!Ou versão duplicada .

Explicação

No MATL, um valor escalar (número, caractere, valor lógico) é o mesmo que uma matriz 1 × 1 que contém esse valor.

Versão normal:

T    % Push true
n    % Number of elements of true: gives 1
Q    % Add 1: gives 2

Versão dobrada:

TT   % Push [true, true]
n    % Number of elements of [true, true]: gives 2
n    % Number of elements of 2: gives 1
Q    % Add 1: gives 2
Q    % Add 1: gives 3

vim, 5

i1<esc>X<C-a>

Sem duplicar:

i1<esc>  insert the literal text "1"
X        delete backwards - a no-op, since there's only one character
<C-a>    increment, giving 2

Com duplicação:

ii11<esc>   insert the literal text "i11"
<esc>       escape in normal mode does nothing
XX          since the cursor is on the last character, delete "i1"
<C-a><C-a>  increment twice, giving 3

Não tenho certeza se esta resposta é válida. Basta postar aqui, caso alguém possa ter idéias daqui.

Node.js com sinalizador -p, 7 bytes

Por Alex Varga :

3/3*22

33//33**2222

Node.js com sinalizador -p, 11 bytes

Antigo:

3*2*0/1+22

33**22**00//11++2222

Saída 22 e 33.

Python 2 REPL, 11 bytes

(3/1)*(2/1)

Isso simplesmente avalia como 3 * 2 = 6. Duplicado, é

((33//11))**((22//11))

que é avaliado como 3 ** 2, que é 3 com a potência de 2 ou 9.

APL, 7 bytes

⊃⍕⌊3×⍟2

Imprime 2.

⊃⊃⍕⍕⌊⌊33××⍟⍟22

Imprime 3.

Experimente online!

Waaat?

Solteiro:

3×⍟2         → 2.079441542  ⍝  3 * ln 2
⌊2.079441542 → 2            ⍝  floor
⊃⍕           → '2'          ⍝  format and take first character

Em dobro:

⍟⍟22          → 1.128508398  ⍝  ln ln 22
×1.128508398  → 1            ⍝ signum
33×1          → 33           ⍝  33 * 1
⌊⌊33          → 33           ⍝  floor
⊃⊃⍕⍕          → '3'          ⍝  format and take first character

Na verdade , 3 bytes

1u*

Experimente online!

Explicação:

1u* Errors are ignored
1   Push 1
 u  Increment
  * Multiply

Versão dobrada:

11uu**

Experimente online!

Explicação:

11uu** Errors are ignored
1      Push 1
 1     Push 1
  u    Increment
   u   Increment
    *  Multiply
     * Multiply

CJam , 4 bytes

],))

Experimente normalmente!

Experimente dobrou!

Explicação

Normal:

]     e# Wrap the stack in an array: []
 ,    e# Get its length: 0
  ))  e# Increment twice: 2

Em dobro:

]         e# Wrap the stack in an array: []
 ]        e# Wrap the stack in an array: [[]]
  ,       e# Get its length: 1
   ,      e# Get the range from 0 to n-1: [0]
    )     e# Pull out its last element: 0
     )))  e# Increment 3 times: 3

05AB1E , 2 bytes

X>

Experimente online!

Explicação:

X> Only top of stack is printed
X  Push X (default 1)
 > Increment

Versão dobrada:

XX>>

Experimente online!

Explicação:

XX>> Only top of stack is printed
X    Push X (default 1)
 X   Push X (default 1)
  >  Increment
   > Increment

Neim , 2 bytes

𝐓>

Experimente online!

Explicação:

𝐓> Implicit 0
𝐓  Factorial
 > Increment

Versão dobrada:

𝐓𝐓>>

Experimente online!

𝐓𝐓>> Implicit 0
𝐓    Factorial
 𝐓   Factorial
  >  Increment
   > Increment

Pitão, 3 bytes

he1

Experimente aqui.

Explicação:

he1
h   Increment
 e   Last digit
  1   1

Versão dobrada:

hhee11

Experimente aqui.

Explicação:

hhee11
h      Increment
 h      Increment
  e      Last digit
   e      Last digit
    11     11

R , 11 bytes

8*(!0)+1*!1

Experimente online!

!é negação e **é exponenciação (um apelido para ^). Os numéricos são convertidos em booleanos: 0para FALSE, todos os outros para TRUE. Booleans são convertidos para inteiros: FALSEpara 0, TRUEpara 1, então !0==1, !1==0,!!00==0 e!!11==1 .

A versão única calcula assim $8\times 1 + 1\times 0=8$e a versão dupla calcula $88^0+11^1=12$.

Cubix , 6 bytes

O.1)W@

Imprime 2.

  O
. 1 ) W
  @

Empurra 1, )incrementa, Wpula para a esquerda para a Oqual sai 2e @termina o programa.

Dobrado, é obviamente o OO..11))WW@@que em um cubo é:

    O O
    . .
1 1 ) ) W W @ @
. . . . . . . .
    . .
    . .

Ele pressiona 1duas vezes, )aumenta duas vezes, Wpula para a esquerda novamente, o que o coloca à direita, na Odireção norte, que sai 3e, em seguida, o próximo comando é o @final do programa.

Experimente online!

Duplicou online!

Klein , 8 6 bytes

/3+@4\

Solteiro , Duplo

Explicação

Para o single, o programa segue um caminho bastante direto. O primeiro espelho desvia-o para o segundo que o desvia através do4 até o final do programa.

O duplo é um pouco mais complexo. Aqui está:

//33++@@44\\

Os dois primeiros espelhos funcionam da mesma forma, no entanto, há um novo espelho devido à duplicação que desvia o ip de volta ao início, é capturado pela duplicata do primeiro espelho e desviado para o final. Tudo o que é executado é o 33++que é avaliado em 6.

TI-Basic, 3 bytes

Solteiro:

int(√(8

A última expressão é implicitamente devolvida / impressa no TI-Basic, pelo que é impressa 2

Dobrado:

int(int(√(√(88

Devoluções / impressões 3

TI-Basic é uma linguagem tokenizada ; int(,, √(e 8são cada um byte na memória.

REPL Ruby, 8 bytes

";3#";22

O REPL imprime apenas o último valor avaliado: 22 .

Dobrado:

"";;33##"";;22

Este tempo 33é o último valor avaliado. A sequência é descartada mais uma vez e a #inicia um comentário.

> <>, 19 8 bytes

32b*!{n;

Impressões 22
Experimente online!

Explicação:

32b   push literals onto the stack: [3,2,11]
*     multiply the top two values: [3,22]
!     skip the next instruction
{     (skipped)
n     pop and print the top value from the stack (22)
;     end execution

Dobrado:

3322bb**!!{{nn;;

Impressões 33
Experimente online!

Explicação:

3322bb push literals onto the stack: [3,3,2,2,11,11]
**     multiply top values (twice): [3,3,2,242]
!      skip next instruction
!      (skipped)
{{     rotate the stack to the left (twice): [2,242,3,3]
nn     pop and print the top two values from the stack (33)
;      end execution

Versão antiga:
Normal:

11+!vn;
    n
    ;

Impressões 2
Experimente online!

Explicação:

1    push 1 on the stack: [1]
 1    push 1 on the stack: [1,1]
  +    add top two values of the stack: [2]
   !    skip the next instruction
    v    (skipped)
     n    print the top value of the stack (2)
      ;    end execution

Dobrado:

1111++!!vvnn;;
        nn
        ;;

Impressões 3
Experimente online!

Explicação:

1111    push four 1's on the stack: [1,1,1,1]
    +    add top two values of the stack: [1,1,2]
     +    add top two values of the stack: [1,3]
      !    skip the next instruction
       !    (skipped)
        v    change direction of execution (down)
         n    print the top value of the stack (3)
          ;    end execution

Zsh , 14 bytes

<:|echo 22
3
:

Experimente online!

Obter um programa completo em um idioma não-golfe para imprimir qualquer coisa com o código-fonte duplicado como esse é um desafio. O Zsh é muito útil para isso, porque arquivos e heredocs são implicitamente transmitidos para cat. Vamos dar uma olhada na primeira linha nos dois casos:

<:|echo 22            # Give the file : on stdin to cat. cat pipes to 'echo 22', which ignores stdin
<<::||eecchhoo  2222  # Start heredoc on following lines with EOF string '::', pass to cat.
                      # Since cat exits 0, 'eecchhoo 2222' is not executed

Enquanto 3não for um programa, o primeiro programa será impresso apenas 22. O segundo programa será impresso 33rodeado por novas linhas extras (devido à duplicação).

Se 3for uma função / programa / alias, essa solução de 18 bytes ainda funcionará!

<:|echo 22\\c\
3
:

Experimente online!

A última \é a continuação da linha; portanto, a nova linha é descartada, efetivamente fazendo a declaração de eco echo '22\c3'. As \ccausas eco para parar de imprimir depois 22(o que também acontece para suprimir a nova linha).

Perl 6 , 14 bytes

'|d 3#';say 22

Experimente online! Experimente dobrou!

Isso usa a função de depuração convenientemente nomeada ddpara gerar o programa duplicado para STDERR. Para separar a lógica, colocamos o programa duplicado entre aspas, que depois se cancelam quando duplicados, junto com um caractere #de comentário para comentar o programa normal agora inválido.

Stax , 3 bytes

UJ^

Execute e depure

Execute e depure o dobro

Uempurra -1. Jquadrados ^incrementos.

MathGolf , 2 bytes

▬)

Experimente online! Tente dobrar

Semelhante a outras respostas, a primeira instrução produz um 1par quando duplicada e a segunda a incrementa. Nesse caso, usei exponenciação reversa ( 0**0 = 0**0**0 = 1), mas também poderia ter sido uma das !£≤°instruções e talvez até mais que eu tenha perdido.

Japonês , 2 bytes

Outra solução "fatorial + 1".

ÊÄ

Teste-o

ÊÊÄÄ

Teste-o