Basado en este desafío.

En el juego de ritmo osu! , el modificador de dificultad "Doble tiempo" en realidad solo aumenta la velocidad en un 50%.

Su tarea, es escribir un programa que da salida a una positiva incluso entero (mayor que 0), y cuando se duplica cada byte / personaje (a elegir cuál) en el código fuente, se debe emitir el número multiplicado por 1,5.

Por ejemplo, si su código fuente es ABCy que genera 6, entonces AABBCCdebería generar 9.

Siguiendo las reglas del desafío original:

Reglas

• Debes construir un programa completo.
• La fuente inicial debe tener al menos 1 byte de longitud.
• Ambos enteros deben estar en la base 10 (está prohibido enviarlos a cualquier otra base o con notación científica).
• Su programa no debe tomar entradas (o tener una entrada vacía no utilizada) y no debe arrojar ningún error (las advertencias del compilador no se consideran errores).
• La salida de los enteros con espacios finales / iniciales está permitida.
• No puede asumir una nueva línea entre copias de su fuente.
• Este es el código de golf , por lo que gana la menor cantidad de bytes en cada idioma .
• Se aplican las lagunas predeterminadas .

Me imagino que esto será mucho menos trivial que el desafío original, ¡pero esperamos ver algunas respuestas creativas y únicas!

Pilones , 7 5 4 bytes

Elegí un idioma aleatorio en TIO lo usé

46vt

Explicación:

Pruébalo en línea!

46    # Stack is [4, 6]

v     # Reverse the stack [6, 4]

t     # take top of stack 4

Doblado:

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 gracias a officialaimm

Guardado 1 bytes gracias a Veedrac

Jalea , 2 bytes

!‘

Pruébalo en línea!

Explicación:

!‘ Implicit 0
!  Factorial
 ‘ Increment

Versión duplicada:

!!‘‘

Pruébalo en línea!

Explicación:

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

LibreOffice Calc, 8 bytes

=A2+3
19

Guárdelo como *.csvy ábralo en LibreOffice Calc. Obtendrás 22 en A1.

Doblarlos:

==AA22++33

1199

Obtendrás 33 en A1

MATL , 3 bytes

TnQ

Pruébalo en línea! O versión duplicada .

Explicación

En MATL, un valor escalar (número, carácter, valor lógico) es lo mismo que una matriz 1 × 1 que contiene ese valor.

Versión normal:

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

Versión duplicada:

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>

Sin 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

Con duplicación:

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

No estoy seguro si esta respuesta es válida. Solo publique aquí en caso de que alguien tenga ideas de aquí.

Nodo.js con bandera -p, 7 bytes

Por Alex Varga :

3/3*22

33//33**2222

Nodo.js con bandera -p, 11 bytes

El viejo:

3*2*0/1+22

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

Salida 22 y 33.

Python 2 REPL, 11 bytes

(3/1)*(2/1)

Esto simplemente evalúa a 3 * 2 = 6. Duplicado, es

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

que evalúa a 3 ** 2, que es 3 a la potencia de 2, o 9.

APL, 7 bytes

⊃⍕⌊3×⍟2

Impresiones 2.

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

Impresiones 3.

Pruébalo en línea!

Waaat?

Soltero:

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

Doble:

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

En realidad , 3 bytes

1u*

Pruébalo en línea!

Explicación:

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

Versión duplicada:

11uu**

Pruébalo en línea!

Explicación:

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

CJam , 4 bytes

],))

¡Pruébalo normalmente!

¡Pruébalo doblado!

Explicación

Normal:

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

Doble:

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

Pruébalo en línea!

Explicación:

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

Versión duplicada:

XX>>

Pruébalo en línea!

Explicación:

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

Neim , 2 bytes

𝐓>

Pruébalo en línea!

Explicación:

𝐓> Implicit 0
𝐓  Factorial
 > Increment

Versión duplicada:

𝐓𝐓>>

Pruébalo en línea!

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

Pyth, 3 bytes

he1

Pruébalo aquí

Explicación:

he1
h   Increment
 e   Last digit
  1   1

Versión duplicada:

hhee11

Pruébalo aquí

Explicación:

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

R , 11 bytes

8*(!0)+1*!1

Pruébalo en línea!

!es negación, y **es exponenciación (un alias para ^). Los números se convierten en booleanos: 0a FALSE, todos los demás a TRUE. Booleanos se convierten en enteros: FALSEa 0, TRUEa 1, por lo que !0==1, !1==0, !!00==0y !!11==1.

La versión única calcula así $8\times 1 + 1\times 0=8$, y la versión doble calcula $88^0+11^1=12$.

Cubix , 6 bytes

O.1)W@

Impresiones 2.

  O
. 1 ) W
  @

Empujes 1, )incrementos,W salta a la izquierda a Oqué salidas 2y @finaliza el programa.

Doblado, obviamente OO..11))WW@@ , lo que en un cubo es:

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

Empuja 1dos veces, )aumenta dos veces, Wsalta nuevamente a la izquierda, lo que lo coloca a la derechaO hacia el norte, que sale 3, y luego el siguiente comando es el @que finaliza el programa.

Pruébalo en línea!

Duplicado en línea!

Klein , 8 6 bytes

/3+@4\

individual , doble

Explicación

Para el single, el programa sigue un camino bastante sencillo. El primer espejo lo desvía hacia el segundo que lo desvía a través del4 hasta el final del programa.

El doble es un poco más complejo. Aquí está:

//33++@@44\\

Los primeros dos espejos funcionan de la misma manera, sin embargo, hay un nuevo espejo debido a la duplicación que desvía la ip hacia el principio, es atrapado por el duplicado del primer espejo y desviado hacia el final. Todo lo que se ejecuta es el 33++que se evalúa como 6.

TI-Basic, 3 bytes

Soltero:

int(√(8

La última expresión se devuelve / imprime implícitamente en TI-Basic, por lo que imprime 2

Doblado:

int(int(√(√(88

Devoluciones / impresiones 3

TI-Basic es un lenguaje tokenizado ; int(,, √(y 8cada uno de los bytes en memoria.

Ruby REPL, 8 bytes

";3#";22

El REPL sólo imprime el último valor evaluado: 22.

Doblado:

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

Esta vez 33es el último valor evaluado. La cadena se descarta una vez más y #comienza un comentario.

> <>, 19 8 bytes

32b*!{n;

Impresiones 22
Pruébelo en línea!

Explicación:

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

Doblado:

3322bb**!!{{nn;;

Impresiones 33
Pruébelo en línea!

Explicación:

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

Versión Antigua:
Normal:

11+!vn;
    n
    ;

Impresiones 2
Pruébelo en línea!

Explicación:

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

Doblado:

1111++!!vvnn;;
        nn
        ;;

Impresiones 3
Pruébelo en línea!

Explicación:

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
:

Pruébalo en línea!

Obtener un programa completo en un lenguaje que no sea de golf para imprimir cualquier cosa con el código fuente duplicado de esta manera es un desafío. Zsh es muy útil para esto, porque los archivos y heredocs se pasan implícitamente a cat. Echemos un vistazo a la primera línea en ambos 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

Mientras 3no sea un programa, solo se imprimirá el primer programa 22. El segundo programa se imprimirá 33rodeado de nuevas líneas adicionales (debido a la duplicación).

Si 3es una función / programa / alias, ¡entonces esta solución de 18 bytes seguirá funcionando!

<:|echo 22\\c\
3
:

Pruébalo en línea!

La última \es la continuación de la línea, por lo que la nueva línea se descarta, lo que efectivamente hace la declaración de eco echo '22\c3'. El \ceco deja de imprimir después 22(lo que también suprime la nueva línea).

Perl 6 , 14 bytes

'|d 3#';say 22

Pruébalo en línea! ¡Pruébalo doblado!

Esto utiliza la función de depuración convenientemente nombrada ddpara enviar el programa duplicado a STDERR. Para separar la lógica, encerramos el programa duplicado entre comillas, que luego se cancelan entre sí cuando se duplica, junto con un carácter #de comentario para comentar el programa normal ahora no válido.

Stax , 3 bytes

UJ^

Ejecutar y depurarlo

Ejecuta y depura el duplicado

Uempuja -1. Jcuadrícula. ^incrementos

MathGolf , 2 bytes

▬)

Pruébalo en línea! Pruébalo doblado

Similar a otras respuestas en que la primera instrucción produce un 1par cuando se duplica y la segunda la incrementa. En este caso, he usado la exponenciación inversa ( 0**0 = 0**0**0 = 1), pero también podría haber sido cualquiera de las !£≤°instrucciones y quizás incluso más que me perdí.

Japt , 2 bytes

Otra solución "factorial + 1".

ÊÄ

Pruébalo

ÊÊÄÄ

Pruébalo