Es gab einige Herausforderungen, die das Verdoppeln des Quellcodes betrafen: hier und hier . Die Aufgabe, die wir hier haben, ist etwas schwieriger, sollte aber in fast jeder Sprache machbar sein.

In dieser Herausforderung nehmen Sie eine beliebige positive ganze Zahl auf. Ihr Programm muss diese ganze Zahl doppelt ausgeben . Wenn Ihr Quellcode verdoppelt wird, nimmt er eine positive Ganzzahl auf und gibt sie im Quadrat aus .

Wie wird Ihr Quellcode verdoppelt? Nun, Sie können es nach Ihren Wünschen haben . Das heißt, können Sie Ihren Quellcode aufgeteilt in Strings von Bytes oder Zeichen (oder Token in Zeichen übersetzten langs) von jeder gleich lang Sie wollen , und wiederholen Sie die einzelnen Blöcke zweimal hintereinander.

Für ein erstes Programm von ABCDEFGHIJKL(Länge 12) sind hier alle möglichen Doppelprogramme:

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

Beachten Sie, dass dies bedeutet, dass Programme mit Primlängen nur auf zwei Arten verdoppelt werden können: jedes Zeichen wird verdoppelt oder das vollständige Programm wird zweimal wiederholt.

Regeln:

• Code muss ein vollständiges Programm oder eine vollständige Funktion sein.
• Standardlücken sind verboten.
• Standard-E / A-Methoden sind zulässig.
• Alle Zeichen / Bytes, einschließlich Leerzeichen und Zeilenumbrüchen, werden in der Länge des Codes gezählt und tragen zu Chunks bei.
• Sie können davon ausgehen, dass die Eingabe und das Quadrat durch den Int / Integer-Typ Ihrer Sprache dargestellt werden können.
• Sie dürfen keinen abschließenden Zeilenvorschub oder ein anderes Zeichen annehmen.
• Geben Sie Ihre Blockgröße in der Überschrift nach der Byteanzahl an.
• Das ist Code-Golf , also sind kürzere Programme besser! Wenn zwei Programme die gleiche Länge haben, gewinnt das Programm, das die kleinere Blocklänge verwendet. (Wenn Sie ein längeres Programm haben, das eine kleinere Blocklänge verwendet, lohnt sich auch das Posten!)
• Wenn für Ihr Programm eine zweite Eingabe / Zeile erforderlich ist, können Sie keine Annahmen zu deren Wert treffen. Insbesondere sollte Ihr Programm funktionieren, wenn die zweite Eingabe leer, dieselbe wie die erste oder eine andere Ganzzahl ist. Wenn Ihr Programm keine zweite Eingabe / Zeile benötigt, können Sie diese Einschränkung ignorieren.

Sandbox-Link

Perl 5 , 8 Bytes (Blockgröße 4)

$_*=~~+2

Probieren Sie es online aus oder probieren Sie die doppelte Version .

Unary ~ist das bitweise Negieren, also ist das zweimalige Anwenden ein Noop. Das Basisprogramm multipliziert also einfach $_(die implizite Input-Output-Variable) mit 2.

Binär ~~ist Smartmatch, das einen Booleschen Wert zurückgibt. ~~+2~~+2analysiert als (~~+2) ~~ (+2). Da 2 gleich 2 ist, ergibt dies true (1). Somit multipliziert das verdoppelte Programm zuerst mit $_1 und multipliziert dann mit sich $_selbst.

05AB1E , 4 Byte ( Blockgröße 2 oder 4)

·Inr

Versuchen Sie es online oder doppelt als einzelner 4-Byte-Block oder doppelt als zwei 2-Byte-Blöcke .

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3 , 26 Bytes (Blockgröße 13)

lambda n:"and n*n#"and 2*n

Probieren Sie es online!

Verdoppelt:

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

Diese Lösung wird von @Grimy bereitgestellt.

Python 3 , 32 30 28 Bytes (Blockgröße 16 15 14)

lambda n:bool(0)*n*n or  2*n

Probieren Sie es online!

-4 Bytes dank @negativeSeven

Verdoppelt:

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

Probieren Sie es online!

Die Funktion nutzt die einzigartige Blockregel dieser Herausforderung.

Befunge-98 (FBBI) , 8 Bytes ( Blocklänge 2)

;&:#* +q

Probieren Sie es online!

;&;&:#:#* * +q+q

Probieren Sie es online! (verdoppelt)

Mit Ausnahme des Kontrollflusses wird das erste Programm ausgeführt &:+q(Eingabe, Stapelanfang duplizieren, Hinzufügen, Beenden mit Rückkehrcode) und das zweite Programm wird ausgeführt (Eingabe, Stapelanfang &:*+qduplizieren, Multiplizieren, Hinzufügen (Summen mit impliziter 0), Beenden mit Rückkehrcode Code)

Hexagony , 14 Bytes ( Blockgröße 14)

?"+==*/}=+!@!<

Erweitert:

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

Probieren Sie es online!

Verdoppelt

?"+==*/}=+!@!<?"+==*/}=+!@!<

Erweitert:

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

Probieren Sie es online verdoppelt!

Hexagony befindet sich in dieser Herausforderung in einer etwas seltsamen Position, da es nicht viel schwieriger ist, die Aufgabe tatsächlich zu erfüllen, als einfach die beiden einzelnen Programme schreiben zu können. Das Golfspielen erwies sich jedoch als ziemlich schwierig.

Diese Lösung ist die triviale Idee in der kürzesten Form, die ich finden könnte, aber ich vermute, dass es kürzere, klügere Antworten gibt. Diese Version setzt sehr naiv zwei Werte auf den Eingang und summiert oder multipliziert sie, je nachdem, ob die Quelle verdoppelt wird. Die einzige Wiederverwendung von Code ist die"+ die der Kopiercode für das doppelte Programm so kurz wird, dass er in den nicht verwendeten Platz des ursprünglichen Programms passt.

Ich vermute, dass die Verwendung der IP-Änderungsanweisungen []das Isolieren der Teile erleichtert, aber eine wirklich ideale Lösung wird viel Code zwischen den beiden wiederverwenden. Ich habe ein Hilfsprogramm erstellt , um den Hexagony-Quellcode zu verdoppeln. Beachten Sie, dass nachfolgende No-Ops entfernt werden. Wenn Sie also Platzhalter-No-Ops am Ende haben möchten, geben Sie einfach ein anderes Zeichen ein und ändern Sie es anschließend wieder. Es kann verschiedene Chunk-Größen verarbeiten, obwohl ich noch keinen Code für die Ausgabe jedes möglichen Programms geschrieben habe (Hexagony bietet sich an, um die volle Chunk-Größe zu verwenden).

Hexagony , 12 Bytes ( Blockgröße 4)

?"2+...}=*!@

Probieren Sie es online!

Formatiert:

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

Und verdoppelt , dann formatiert:

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

Grundsätzlich wird dabei die erste Kante auf die Eingabe und dann die zweite Kante auf eine der beiden 2oder eine Kopie der Eingabe festgelegt. Anschließend werden diese beiden Kanten mit der dritten Kante multipliziert, gedruckt und beendet. Die Liste der ausgeführten Anweisungen ist gerade

?"2}=*!@

und

?"2+}=*!@

Der einzige Unterschied ist das +Überschreiben 2des zweiten Programms.

JavaScript (ES6),  24  22 Bytes

Trotz seines ungewöhnlichen Formats ist dies die Definition einer anonymen Funktion, die entweder direkt aufgerufen oder einer Variablen zugewiesen werden kann.

+(g=x=>x*x)?g:(x=>x*2)

Probieren Sie es online!

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

Probieren Sie es online doppelt aus!

Wie?

Das Anwenden des Unären +auf eine Funktion wird als Versuch interpretiert, sie zu einer Zahl zu zwingen, und führt zu NaN . Daher ist die Führung +(g=x=>x*x)in beiden Versionen falsch.

Auf der anderen Seite führt das Anwenden der Binärdatei +zwischen zwei Funktionen zu einer Zeichenfolge. Daher (x=>x*2)+(g=x=>x*x)ist in der doppelten Fassung wahr.

Perl 6 , 8 Bytes (Blockgröße 1)

* *<1 2>

Probieren Sie es online! Probieren Sie es doppelt aus!

Ein Whatever / HyperWhatever-Lambda, das eine Zahl annimmt und eine Zahl für das erste Programm und eine Singleton-Liste für das zweite Programm zurückgibt. Grundsätzlich wird dabei die exakt gleiche Logik beibehalten, mit der Ausnahme, dass der Multiplikationsoperator ( *) durch den Exponentialoperator ( **) ersetzt wird.

**  **<<11  22>>

Das Whatever-Literal (verwirrenderweise auch durch a dargestellt *) wird zu einem HyperWhatever ( **) verdoppelt, das im Grunde dasselbe ist, außer dass es Listen überlagert . Das Leerzeichen wird benötigt, um das Whatever-Literal von der Multiplikation zu trennen, und wird beim Verdoppeln ignoriert. Anstelle von nur 2(was sich verdoppeln würde 22) verwenden wir eine Liste mit zwei Elementen, die in einem numerischen Kontext mit 2 bewertet werden. Das <>kann zu einer Liste mit Interpolation verdoppelt werden, und die beiden darin enthaltenen Elemente werden verdoppelt, aber keines dieser Elemente ändert die Länge der Liste.

Runenverzauberungen , 9 Bytes (Blockgröße 3)

i3?:*@:+@

Probieren Sie es online!
Probieren Sie es doppelt aus!

Die 3?nächsten 3 Anweisungen werden übersprungen, was zu einer (ausgeführten) Anweisung führt i3?...:+@. Wenn es verdoppelt wird, wird ausgeführt, i3?...:*@wobei .die 3 NOP-Anweisungen dargestellt werden. @ist "ganzen Stapel drucken und beenden."

C # (Visual C # Interactive Compiler) / Javascript, 22 Byte, Blockgröße 11

m=>/*      /2*m//*/m*2

Probieren Sie es online!

Brain-Flak , 48 30 Bytes (Blockgröße 10)

(({}))<>( {({}[()])}{}<>{}{}) 

Probieren Sie es online! Probieren Sie es doppelt aus!

Dies dauert im Grunde genommen drei Schritte, und wenn verdoppelt, werden diese Schritte jeweils zweimal ausgeführt. Das anfängliche Programm ist:

1. Duplizieren Sie die TOS, wechseln Sie die Stapel und geben Sie einen Wert ein
2. Ermitteln Sie die dreieckige Zahl n * (n-1) / 2 des TOS
3. Pop TOS, wechsle Stack und Pop zweimal und drücke dann das Ergebnis.

Für eine Eingabe nin ein ungetrübtes Programm ergibt sich:

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

Für das Doppelprogramm:

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

Brain-Flak , 76 Bytes, 76 Bytes

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

Probieren Sie es online!

Verdoppelt (mit Zeilenvorschub zur Verdeutlichung)

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

Probieren Sie es online!

Hier ist eine Version, die ein komplexeres Verdopplungsverfahren verwendet. Es sind 5 Blöcke der Größe 15 vorhanden. Der Code beträgt hier 46 Byte, ist jedoch aufgrund der erforderlichen Auffüllung wesentlich länger.

105 90 Bytes, 15-Byte-Stücke

(              {<><({}()())><><><            <>>({})({}[()])}{}            )<>            

Probieren Sie es online!

Verdoppelt (mit Zeilenumbrüchen zur Verdeutlichung)

(              (              
{<><({}()())><>{<><({}()())><>
<><            <><            
<>>({})({}[()])<>>({})({}[()])
}{}            }{}            
)<>            )<>            

Probieren Sie es online!

Cubix , 18 bis 14 Byte (Blocklänge 9 bis 7)

*OI$|:/@O+:I. 

Beachten Sie das nachfolgende Leerzeichen. Probieren Sie es online!

Verdoppelt:

*OI$|:/*OI$|:/@O+:I. @O+:I. 

Auch hier gibt es ein Leerzeichen. Probieren Sie es online!

Erläuterung

Die Hauptidee ist, dass durch das Verdoppeln des Codes der Würfel größer wird und der Befehlszeiger an einem anderen Symbol beginnt. Da das Additionsprogramm nicht auf einen Würfel der Seitenlänge 1 gelegt werden kann, beträgt die Seitenlänge 2. Außerdem muss sich der doppelte Code auf einem Würfel der Seitenlänge 3 befinden, sodass der doppelte Code mindestens 25 Byte betragen muss . Dies bedeutet, dass der Code mindestens 13 Byte lang sein muss. Somit kann maximal 1 Byte mehr gespeichert werden.

Nun zum eigentlichen Code. Die erste Beobachtung ist, dass die Oberseite (dh die ersten 4 Zeichen) vom Additionsprogramm nicht verwendet werden. Wenn das fünfte Zeichen die IP-Adresse um den Würfel widerspiegelt, können wir außerdem zwei weitere Zeichen freigeben. Wir werden diese Zeichen verwenden, um das Quadrierungsprogramm zu platzieren.

Mornington Crescent , 656 Bytes (Blockgröße 328)

Nur um der Theorie mehr Gewicht zu verleihen, dass dies in fast jeder Sprache gelöst werden kann ...

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(Der abschließende Zeilenumbruch ist wichtig)

Probieren Sie die Single-Version! ... oder ... Probieren Sie die doppelte Version!

Die Theorie hier ist einfach: In der Einzelversion wird 'Bounds Green' mit einer zufälligen Zeichenfolge gefüllt, in der doppelten Version wird sie mit der quadrierten Eingabe gefüllt. Nachdem der Block beendet ist, verdoppeln beide Versionen die 'Eingabe', aber in der verdoppelten Version des Codes wurde die Eingabe durch 0 ersetzt.

Dieses Ergebnis wird an Bounds Green zurückgegeben, das zweimal eine max () -Operation ausführt, bevor das Ergebnis in die Ausgabe übernommen wird. In der Single-Version bleibt die Verdopplung unverändert (Int und String werden nur hin und her geschaltet), in der Double-Version wird jedoch die 0 durch das bereits in Bounds Green gespeicherte quadrierte Ergebnis ersetzt.

JavaScript (Node.js) , 15 bis 12 Byte (Blockgröße: 6)

x=>/**/2*(x)

Probieren Sie es online!

Einzelfall:

x=>/**/2*(x)

Doppel fall:

x=>/**x=>/**/2*(x)/2*(x)

Scheint auch in C # und Java zu funktionieren, wenn =>auf ->?

R , 42 35 28 Bytes (Blockgröße 4)

Jetzt mit einem kleineren Teil und ohne Fehler. Ich habe auch eine längere Lösung mit Blockgröße 3; siehe unten.

Ich glaube nicht, dass es möglich ist, eine R-Antwort mit Blockgröße 1 oder 2 zu schreiben. Ich werde jedem, der mir das Gegenteil beweist, gerne ein Kopfgeld geben.

s =scan#
n=s()# 
  
n/2*4#  

Probieren Sie es online!

Das # ist für Kommentare in R. Die 3. Zeile besteht nur aus Leerzeichen, die einen Block aus Zeilenvorschub + 2 Leerzeichen + Zeilenvorschub bilden, so dass der vorherige und der nächste Block keinen Zeilenvorschub haben können.

Verdoppelt wird es:

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

Probieren Sie es online!

Die Einzelversion berechnet $\frac n2\times4=2n$; Die doppelte Version berechnet$\frac n2\times \frac n2\times4=n^2$.

Hier ist eine etwas längere Lösung, jedoch mit Blockgröße 3:

R , 39 Bytes (Blockgröße 3)

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

Probieren Sie es online!

Verdoppelt:

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

Probieren Sie es online!

Beachten Sie, dass Giuseppe eine andere R-Antwort mit einem Block von 30 Bytes hat.

R , 59 30 Bytes (Blockgröße 59 30)

F=F+1;f=function(n)n*c(2,n)[F]

Probieren Sie es online!

Dank an Robin Ryder , der dies inspiriert hat; erhöht sich Fjedes Mal, und die Funktion fwählt den entsprechenden Ausgang aus.

Das ist nicht sonderlich interessant, aber zweifellos wird etwas ausgeklügeltes ausgedacht, das die Blockgröße manipuliert. Wie erwartet, hat Robin Ryder dieses Modell entwickelt, das sowohl kürzer als auch gut manipuliert ist.

PowerShell , 22 Byte (Blockgröße 11)

param($p)
#   /
2 * $p

Probieren Sie es online aus .

Verdoppelt:

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

Diese Lösung basiert auf der @ ShieruAsakoto- Lösung .

@ Grimy- Lösung , die in PowerShell konvertiert wurde, 26 Byte (Blockgröße 13)

param($p)$t=';$p*$p#';$p*2

Probieren Sie es online aus .

Verdoppelt:

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Perl 5 ( -p), 22 15 Bytes

-7 Bytes dank Grimy

$_*=$'/4||2;//;

TIO

Kohle , 13 Bytes

ＰＩ×Ｉθ⎇υＩθ²⊞υω

Probieren Sie es online! Erläuterung: Die vordefinierte leere Liste ist falsch, sodass die Eingabe mit 2 multipliziert wird. Wenn der zweite Durchgang verdoppelt wird, wird die leere Zeichenfolge in die Liste verschoben, sodass die Eingabe stattdessen mit sich selbst multipliziert wird. Probieren Sie es online! In ausführlicher Syntax entspricht dies Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 Bytes

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

Meine Python-Fähigkeiten saugen ein bisschen, so kann auf jeden Fall Golf gespielt werden. Basierend auf der Python-Antwort in der " Herausforderung Ich die Quelle, du verdoppelst die Ausgabe! " .

Stücklänge 53.

Probieren Sie es online oder doppelt aus .

Java 8, 62 Bytes

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

Brockenlänge 62.

Probieren Sie es online oder doppelt aus .

Erläuterung:

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

In Java sind die verfügbaren Kommentare // commentund /* comment */. Die hier kombiniert werden, um bestimmte Teile zu überschreiben. Sehen Sie, wie diese Kommentare dank der Java-Hervorhebung funktionieren:

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

Das verdoppelte Programm hat eine benutzerdefinierte ByteKlasse und ihren Wert erstellt SIZE=9, wodurch die Standardklasse java.lang.Byteund ihr Wert überschrieben werden SIZE=8.

Japt , 7 5 Bytes

*N²jJ

Versuchen Sie es | Verdoppelt

²drückt 2 auf das Array von Eingaben Nund jentfernt und gibt das Element am Index zurück J=-1(dh das neu eingefügte)2 ) und multipliziert die Eingabe durch das.

Wenn es verdoppelt wird, wird es Jmit multipliziert 2, sodass das Element am Index -2(dh die Eingabe) mit zurückgegeben jund als Multiplikator verwendet wird.

Gelee , 8 6 Bytes (Blocklänge 3)

Ḥ;²3ị 

Probieren Sie es online!

Verdoppelt

Schöne Lösung: Lua , 66 Bytes (Blockgröße 66 Bytes)

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

Probieren Sie es online! (Verdopple es selbst, es ist nicht so schwer)

Oh ja, ziemlich sicher, dass es eine kürzere Lösung dafür gibt, aber es ist das Beste, was ich auf diese Weise finden konnte. Nehmen Sie die Eingabe als erstes Argument.

Kurze Erklärung: Das ganze Geschäft mit aist für alle offensichtlich, während der zweite Teil mit xinteressanter ist. Grundsätzlich erstelle ich eine Tabelle (oder aktualisiere eine vorhandene im zweiten Durchgang) mit Finalizer (__gc Metamethode), die beim Beenden des Programms aufgerufen wird.

Lahme Lösung: Lua , 60 Bytes (Blockgröße 30 Bytes)

a=a and...^2 or ...*2;                     print(a)os.exit()

Probieren Sie es online!oder Versuchen Sie es verdoppelt!

Kleiner und mit besserem Chunking, aber letztendlich langweilig und lahm ohne clevere Tricks. Ich bin mir ziemlich sicher, dass zu diesem Thema keine Kommentare erforderlich sind.

J , ^{15 10} 9 Bytes

+: :(*-:)

Probieren Sie es online!

Doppelversion: Probieren Sie es online!

f : gErstellt ein Verb, das ausgeführt wird, fwenn es mit einem Argument und gmit zwei Argumenten aufgerufen wird. Unser Programm wird also doppelt +:mit der Originalquelle ausgeführt und *-:wenn die Quelle verdoppelt wird.

Dies funktioniert, weil ein Zug von zwei Verben in J zu einem Hook wird und somit f fausgeführt wird alsy f (f y) y die ursprüngliche Eingabe. Außerdem *-:ist es selbst ein "dyadischer Haken", der durch Multiplizieren *des linken Arg mit der Hälfte funktioniert-: des rechten Args . Das linke Argument ist die ursprüngliche Eingabe, und das rechte Argument ist die doppelte Eingabe. Dadurch wird das Quadrat der ursprünglichen Eingabe erzeugt.

ursprüngliche Antwort

J , 15 Bytes

*:@]`(+:@])@.=~

Probieren Sie es online!

Doppelte Version: Probieren Sie es online!

In der Einzelversion haben wir ein einzelnes Verb, das Agenda verwendet @., um die if ... then-Logik auszuführen: Wenn das Argument gleich sich selbst ist=~ , nehmen Sie das Argument und verdoppeln Sie es (+:@[).

Wenn wir den Code jedoch verdoppeln, erhalten wir einen J-Hook. Nenne das Verb fund die Eingabe y. Dann f fläuft der Hook so ab:

y f (f y)

Dies bedeutet, dass jetzt die ursprüngliche Eingabe das linke und die rechte das doppelte Argument ist. Da diese nicht gleich sein werden, =~wird diesmal false zurückgegeben, und jetzt werden wir die andere Abzweigung der Agenda ausführen, dh *:@]"Quadrieren des richtigen Arguments". Und da ~die Eingaben eines dyadischen Verbs umgekehrt werden, ist das rechte Argument die ursprüngliche Eingabe.

Python 3 , 60 Bytes

Stückgröße 6.
Keine gute Lösung, aber es funktioniert. Dies ist eine so einzigartige Herausforderung, dass Sie wirklich aus einer anderen Perspektive denken.

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

Probieren Sie es online!

Verdoppelt:

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

Probieren Sie es online!

Kaskade , 13 Bytes (Blockgröße 13)

]
&/2
#
*
 2&

Probieren Sie es online!

]
&/2
#
*
 2&]
&/2
#
*
 2&

Probieren Sie es doppelt aus!

Das war ziemlich schwierig. Der Grundgedanke dabei ist, die Eingabe multipliziert mit 2für das erste Programm zu drucken und die zu ersetzen2 durch eine Kopie der Eingabe für das zweite .

Erläuterung:

Der ausgeführte Teil des ersten Programms sieht so aus

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

Das verdoppelte Programm fügt im Grunde das erste ]bis zum Ende der letzten Zeile hinzu, so dass das Programm das umschließt und nicht das &. Das macht es zu

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Zsh , 30 Bytes ( Blockgröße 10)

m=$m[1]*2
x=$[$1$m]
return $x

Probieren Sie es online! Probieren Sie es doppelt aus!

Missbraucht die Tatsache, dass $varin $[$var]zuerst erweitert und dann im arithmetischen Kontext ausgewertet wird.

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

Wenn jemand etwas dagegen unternehmen möchte, ist dies die 24/8Lösung, die mir am nächsten kommt (Ausgabe x^2+2bei Verdoppelung).