Sulla base di questa sfida.

Nel gioco del ritmo osu! , il modificatore di difficoltà "Double-time" aumenta la velocità del 50%.

Il tuo compito è scrivere un programma che produca un numero intero pari positivo (maggiore di 0) e quando ogni byte / carattere (a tua scelta quale) nel tuo codice sorgente è duplicato, dovrebbe generare il numero moltiplicato per 1,5.

Ad esempio, se il tuo codice sorgente è ABCe che genera 6, allora AABBCCdovrebbe produrre 9.

Seguendo le regole della sfida originale:

Regole

• È necessario creare un programma completo.
• La fonte iniziale deve essere lunga almeno 1 byte.
• Entrambi gli interi devono essere nella base 10 (è vietato emetterli in qualsiasi altra base o con notazione scientifica).
• Il tuo programma non deve accettare input (o avere input vuoti inutilizzati) e non deve generare alcun errore (gli avvisi del compilatore non sono considerati errori).
• L'output degli interi con spazi finali / iniziali è consentito.
• Non puoi assumere una nuova riga tra le copie della tua fonte.
• Questo è code-golf , quindi vince il minor numero di byte in ogni lingua !
• Si applicano le lacune predefinite .

Immagino che questo sarà molto meno banale della sfida originale, ma speriamo di vedere alcune risposte creative e uniche!

Piloni , 7 5 4 byte

Scelto un linguaggio casuale su TIO lo ha usato

46vt

Spiegazione:

Provalo online!

46    # Stack is [4, 6]

v     # Reverse the stack [6, 4]

t     # take top of stack 4

raddoppiato:

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

Salvato 2 byte grazie a officialaimm

Salvato 1 byte grazie a Veedrac

Gelatina , 2 byte

!‘

Provalo online!

Spiegazione:

!‘ Implicit 0
!  Factorial
 ‘ Increment

Versione doppia:

!!‘‘

Provalo online!

Spiegazione:

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

LibreOffice Calc, 8 byte

=A2+3
19

Salvalo come *.csve aprilo in LibreOffice Calc. Ne otterrai 22 in A1.

Raddoppiali:

==AA22++33

1199

Riceverai 33 in A1

MATL , 3 byte

TnQ

Provalo online! O versione raddoppiata .

Spiegazione

In MATL un valore scalare (numero, carattere, valore logico) è uguale a un array 1 × 1 contenente quel valore.

Versione normale:

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

Versione doppia:

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>

Senza raddoppiare:

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

Con raddoppio:

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

Non sono sicuro che questa risposta sia valida. Pubblica qui nel caso in cui qualcuno possa avere idee da qui.

Node.js con flag -p, 7 byte

Di Alex Varga :

3/3*22

33//33**2222

Node.js con -p flag, 11 byte

Vecchio:

3*2*0/1+22

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

Uscita 22 e 33.

Python 2 REPL, 11 byte

(3/1)*(2/1)

Questo semplicemente valuta 3 * 2 = 6. Duplicato, lo è

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

che corrisponde a 3 ** 2, ovvero 3 alla potenza di 2 o 9.

APL, 7 byte

⊃⍕⌊3×⍟2

Stampe 2.

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

Stampe 3.

Provalo online!

Waaat?

singolo:

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

Doppio:

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

In realtà , 3 byte

1u*

Provalo online!

Spiegazione:

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

Versione doppia:

11uu**

Provalo online!

Spiegazione:

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

CJam , 4 byte

],))

Provalo normalmente!

Provalo raddoppiato!

Spiegazione

Normale:

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

Doppio:

]         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 byte

X>

Provalo online!

Spiegazione:

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

Versione doppia:

XX>>

Provalo online!

Spiegazione:

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

Neim , 2 byte

𝐓>

Provalo online!

Spiegazione:

𝐓> Implicit 0
𝐓  Factorial
 > Increment

Versione doppia:

𝐓𝐓>>

Provalo online!

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

Pyth, 3 byte

he1

Provalo qui.

Spiegazione:

he1
h   Increment
 e   Last digit
  1   1

Versione doppia:

hhee11

Provalo qui.

Spiegazione:

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

R , 11 byte

8*(!0)+1*!1

Provalo online!

!è negazione ed **è esponenziazione (un alias per ^). I numeri vengono convertiti in booleani: 0in FALSE, tutti gli altri in TRUE. Booleani vengono convertiti in numeri interi: FALSEa 0, TRUEa 1, quindi !0==1, !1==0, !!00==0e!!11==1.

La versione singola viene quindi calcolata $8\times 1 + 1\times 0=8$, and the double version computes $88^0+11^1=12$.

Cubix, 6 bytes

O.1)W@

Prints 2.

  O
. 1 ) W
  @

Pushes 1, ) increments, W jumps left to O which outputs 2, and @ finishes the program.

Doubled up, it's obviously OO..11))WW@@, which on a cube is:

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

It pushes 1 twice, ) increments twice, W jumps left again, which puts it at the right-hand O heading north, which outputs 3, and then the next command is @ which terminates the program.

Try it online!

Doubled online!

Klein, 8 6 bytes

/3+@4\

Single, Double

Explanation

For the single the program follows a pretty straightforward path. The first mirror deflects it into the second which deflects it through the 4 to the end of the program.

The double is a little more complex. Here it is:

//33++@@44\\

The first two mirrors work the same, however there is a new mirror due to the doubling which deflects the ip back to the beginning, it is caught by the duplicate of the first mirror and deflected towards the end. All that is run is the 33++ which evaluates to 6.

TI-Basic, 3 bytes

Single:

int(√(8

The last expression is implicitly returned/printed in TI-Basic, so this prints 2

Doubled:

int(int(√(√(88

Returns/prints 3

TI-Basic is a tokenized language; int(, √(, and 8 are each one byte in memory.

Ruby REPL, 8 bytes

";3#";22

The REPL only prints the last value evaluated: 22.

Doubled:

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

This time 33 is the last value evaluated. The string is discarded once again, and a # starts a comment.

><>, 19 8 Bytes

32b*!{n;

Prints 22
Try it online!

Explanation:

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

Doubled:

3322bb**!!{{nn;;

Prints 33
Try it online!

Explanation:

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

Old Version:
Normal:

11+!vn;
    n
    ;

Prints 2
Try it online!

Explanation:

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

Doubled:

1111++!!vvnn;;
        nn
        ;;

Prints 3
Try it online!

Explanation:

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
:

Try it online!

Getting a full program in a non-golfing language to print anything with source code duplicated like this is a challenge. Zsh is very useful for this, because files and heredocs are implicitly passed to cat. Let's take a look at the first line in both cases:

<:|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

So long as 3 is not a program, the first program will only print 22. The second program will print 33 surrounded by extra newlines (due to the duplication).

If 3 is a function/program/alias, then this 18 byte solution will still work!

<:|echo 22\\c\
3
:

Try it online!

The last \ is line continuation, so the newline is discarded, effectively making the echo statement echo '22\c3'. The \c causes echo to stop printing after 22 (which also happens to suppress the newline).

Perl 6, 14 bytes

'|d 3#';say 22

Try it online! Try it doubled!

This uses the conveniently named debug function dd to output the doubled program to STDERR. To separate the logic we encase the doubled program in quotes, which then cancel each other out when doubled, along with a comment character # to comment out the now invalid normal program.

Stax, 3 bytes

UJ^

Run and debug it

Run and debug the doubled one

U pushes -1. J squares. ^ increments.

MathGolf, 2 bytes

▬)

Try it online! Try it doubled

Similar to other answers in that the first instruction produces a 1 even when doubled and the second increments it. In this case, I've used reverse exponentiation (0**0 = 0**0**0 = 1) but it also could have been any of the !£≤° instruction and perhaps even more that I missed.

Japt, 2 bytes

Another "factorial+1" solution.

ÊÄ

Test it

ÊÊÄÄ

Test it