Basé sur ce défi.

Dans le jeu de rythme osu! , le modificateur de difficulté "Double-temps" n'augmente en réalité que la vitesse de 50%.

Votre tâche consiste à écrire un programme qui génère un entier pair positif (supérieur à 0). Lorsque chaque octet / caractère (à vous de choisir) de votre code source est dupliqué, il doit générer le nombre multiplié par 1,5.

Par exemple, si votre code source est ABCet que le résultat est 6, alors le AABBCCrésultat est 9.

En suivant les règles du défi original:

Règles

• Vous devez construire un programme complet.
• La source initiale doit avoir au moins 1 octet de long.
• Les deux nombres entiers doivent être en base 10 (leur sortie dans une autre base ou avec une notation scientifique est interdite).
• Votre programme ne doit pas prendre d’entrée (ou avoir une entrée vide, non utilisée) et ne doit renvoyer aucune erreur (les avertissements du compilateur ne sont pas considérés comme des erreurs).
• La sortie des entiers avec des espaces de fin / fin est autorisée.
• Vous ne pouvez pas supposer de saut de ligne entre les copies de votre source.
• C'est du code-golf , donc le moins d'octets dans chaque langue gagne!
• Les failles par défaut s'appliquent.

J'imagine que ce sera beaucoup moins trivial que le défi initial, mais j'espère que nous verrons des réponses créatives et uniques!

Pylônes , 7 5 4 octets

Choisi une langue au hasard sur TIO utilisé

46vt

Explication:

Essayez-le en ligne!

46    # Stack is [4, 6]

v     # Reverse the stack [6, 4]

t     # take top of stack 4

Doublé:

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

2 octets sauvés grâce à officialaimm

Enregistré 1 octet grâce à Veedrac

Gelée , 2 octets

!‘

Essayez-le en ligne!

Explication:

!‘ Implicit 0
!  Factorial
 ‘ Increment

Version doublée:

!!‘‘

Essayez-le en ligne!

Explication:

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

LibreOffice Calc, 8 octets

=A2+3
19

Enregistrez-le sous *.csvet ouvrez-le dans LibreOffice Calc. Vous obtiendrez 22 en A1.

Double les:

==AA22++33

1199

Vous obtiendrez 33 en A1

MATL , 3 octets

TnQ

Essayez-le en ligne! Ou la version doublée .

Explication

En MATL, une valeur scalaire (nombre, caractère, valeur logique) est identique à un tableau 1 × 1 contenant cette valeur.

Version normale:

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

Version doublée:

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>

Sans doubler:

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

Avec doublage:

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

Pas sûr que cette réponse soit valide. Juste poster ici au cas où quelqu'un pourrait avoir des idées d'ici.

Node.js avec l'indicateur -p, 7 octets

Par Alex Varga :

3/3*22

33//33**2222

Node.js avec l'indicateur -p, 11 octets

Le vieux:

3*2*0/1+22

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

Sortie 22 et 33.

Python 2 REPL, 11 octets

(3/1)*(2/1)

Cela évalue simplement à 3 * 2 = 6. Dupliqué, c'est

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

qui évalue à 3 ** 2, qui est 3 à la puissance de 2, ou 9.

APL, 7 octets

⊃⍕⌊3×⍟2

Impressions 2.

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

Impressions 3.

Essayez-le en ligne!

Waaat?

Unique:

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

Double:

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

Réellement , 3 octets

1u*

Essayez-le en ligne!

Explication:

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

Version doublée:

11uu**

Essayez-le en ligne!

Explication:

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

CJam , 4 octets

],))

Essayez-le normalement!

Essayez-le doublé!

Explication

Ordinaire:

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

Double:

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

X>

Essayez-le en ligne!

Explication:

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

Version doublée:

XX>>

Essayez-le en ligne!

Explication:

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

Neim , 2 octets

𝐓>

Essayez-le en ligne!

Explication:

𝐓> Implicit 0
𝐓  Factorial
 > Increment

Version doublée:

𝐓𝐓>>

Essayez-le en ligne!

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

Pyth, 3 octets

he1

Essayez ici.

Explication:

he1
h   Increment
 e   Last digit
  1   1

Version doublée:

hhee11

Essayez ici.

Explication:

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

R , 11 octets

8*(!0)+1*!1

Essayez-le en ligne!

!est négation et **exponentiation (un alias pour ^). Les nombres sont convertis en booléens: 0à FALSE, tous les autres à TRUE. Booléens sont converties en nombres entiers: FALSEà 0, TRUEà 1, donc !0==1, !1==0, !!00==0et!!11==1 .

La version unique calcule donc $8\times 1 + 1\times 0=8$et la version double calcule $88^0+11^1=12$.

Cubix , 6 octets

O.1)W@

Impressions 2.

  O
. 1 ) W
  @

Pousse 1, )incrémente, Wsaute à gaucheO quelle sortie 2et @termine le programme.

Doublé, c'est évidemment OO..11))WW@@ , ce qui sur un cube est:

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

Il pousse 1deux fois, )incrémente deux fois, Wsaute encore une fois à gauche, ce qui le place à droite en Odirection du nord, ce qui sort 3, puis la commande suivante est celle @qui termine le programme.

Essayez-le en ligne!

Doublé en ligne!

Klein , 8 à 6 octets

/3+@4\

Célibataire , double

Explication

Pour le single, le programme suit un chemin assez simple. Le premier miroir le dévie dans le second qui le dévie à travers le4 jusqu'à la fin du programme.

Le double est un peu plus complexe. C'est ici:

//33++@@44\\

Les deux premiers miroirs fonctionnent de la même manière, mais il y a un nouveau miroir en raison du double qui dévie l'ip au début, il est attrapé par la copie du premier miroir et dévié vers la fin. Tout ce qui est exécuté est le 33++qui est évalué à 6.

TI-Basic, 3 octets

Unique:

int(√(8

La dernière expression est implicitement renvoyée / imprimée dans TI-Basic. 2

Doublé:

int(int(√(√(88

Retours / impressions 3

TI-Basic est un langage à jeton . int(, √(et 8sont chacun un octet en mémoire.

Ruby REPL, 8 octets

";3#";22

Le REPL imprime uniquement la dernière valeur évaluée: 22 .

Doublé:

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

Ce temps 33est la dernière valeur évaluée. La chaîne est à nouveau supprimée et a #commence un commentaire.

> <>, 19 8 octets

32b*!{n;

Prints 22
Essayez-le en ligne!

Explication:

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

Doublé:

3322bb**!!{{nn;;

Prints 33
Essayez-le en ligne!

Explication:

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

Ancienne version:
normale:

11+!vn;
    n
    ;

Prints 2
Essayez-le en ligne!

Explication:

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

Doublé:

1111++!!vvnn;;
        nn
        ;;

Prints 3
Essayez-le en ligne!

Explication:

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 octets

<:|echo 22
3
:

Essayez-le en ligne!

Obtenir un programme complet dans une langue autre que le golf pour imprimer quoi que ce soit avec un code source dupliqué de cette manière constitue un défi. Zsh est très utile pour cela, car les fichiers et heredocs sont implicitement passés à cat. Jetons un coup d'oeil à la première ligne dans les deux cas:

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

Tant que 3 ne s'agit pas d'un programme, le premier programme sera uniquement imprimé 22. Le deuxième programme sera imprimé 33entouré de nouvelles lignes (en raison de la duplication).

Si 3est une fonction / programme / alias, cette solution de 18 octets fonctionnera toujours!

<:|echo 22\\c\
3
:

Essayez-le en ligne!

La dernière \est la continuation de la ligne, la nouvelle ligne est donc rejetée, ce qui en fait une déclaration d'écho echo '22\c3'. Les \ccauses empêchent l’impression après 22(ce qui supprime également la nouvelle ligne).

Perl 6 , 14 octets

'|d 3#';say 22

Essayez-le en ligne! Essayez-le doublé!

Ceci utilise la fonction de débogage bien nommée ddpour sortir le programme doublé vers STDERR. Pour séparer la logique, nous plaçons le programme doublé entre guillemets, qui s'annulent ensuite lorsqu'ils sont doublés, avec un caractère #de commentaire pour commenter le programme normal, désormais invalide.

Stax , 3 octets

UJ^

Exécuter et déboguer

Exécuter et déboguer le doublé

Upousse -1. Jdes carrés. ^incréments.

MathGolf , 2 octets

▬)

Essayez-le en ligne! Essayez-le doublé

Semblable à d'autres réponses en ce que la première instruction produit un 1même lorsque doublé et la seconde l'incrémente. Dans ce cas, j’ai utilisé l’exponentiation inverse ( 0**0 = 0**0**0 = 1), mais c’était aussi l’une des !£≤°instructions et peut-être même plus que ce que j’ai manqué.

Japt , 2 octets

Une autre solution "factorielle + 1".

ÊÄ

Essaye-le

ÊÊÄÄ

Essaye-le