Verdopple es auf deine Weise

31

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

GammaFunktion
quelle
Kann ich das Ergebnis als float ausgeben (mit .0am Ende)?
Val sagt Reinstate Monica
Dürfen wir das Quadrat zweimal drucken, wenn der Code verdoppelt wird? Einfacher Code 5 -> 10:; Doppelcode 5 -> 25 25.
Robin Ryder
@RobinRyder Nein, das dürfen Sie nicht.
GammaFunction
@val Sie können als float ausgeben.
GammaFunction

Antworten:

18

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.

Grimmig
quelle
17

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)
Grimmig
quelle
15

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.

Joel
quelle
3
26: TIO
Grimmy
1
@ Grimy Netter Ansatz. Ich denke, es ist anders genug und verdient einen eigenen Beitrag.
Joel
1
@Grimy Ich habe Ihre Lösung zu meinem Beitrag hinzugefügt, da Sie anscheinend nicht daran interessiert sind, einen separaten Beitrag zu verfassen.
Joel
9

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)

negative sieben
quelle
9

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).

FryAmTheEggman
quelle
2
@JoKing Gut gemacht! Es ist ziemlich anders als meine Antwort, also möchten Sie es posten (die Verwendung der unterschiedlichen Blockgröße zum Auffüllen von nicht verwendetem Speicherplatz ist wirklich ordentlich!)? Ansonsten werde ich es und eine Erklärung hinzufügen, wenn ich mehr Zeit habe.
FryAmTheEggman
9

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.

Scherzen
quelle
8

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.

Arnauld
quelle
Alter, hast du bemerkt, dass dies auch in Stücke von 11 aufgeteilt werden kann?
Gust van de Wal
7

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.

Scherzen
quelle
5

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

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

Probieren Sie es online!

Verkörperung der Ignoranz
quelle
Funktioniert auch in JavaScript
Shaggy
1
Funktioniert auch in Java durch Ändern des =to -. Gute Antwort!
Kevin Cruijssen
2
Mir gefällt, wie der Kommentar tatsächlich beschreibt, was der Code tut. : p
Arnauld
5

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: 
Scherzen
quelle
28 Bytes (
Blockgröße
4

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!

Weizen-Assistent
quelle
4

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.

Luke
quelle
4

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!


Dies war eine besonders knifflige Herausforderung in Mornington Crescent, da das Programm eine solch starre Struktur haben muss. Es ist auch wichtig zu beobachten, wo die Verdopplung stattfinden würde, da das Teleportieren zwischen Stationen in London illegal ist.

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.


Wenn meine Erklärung nicht gut genug war, empfehle ich Ihnen, London zu besuchen und die beiden Routen selbst auszuprobieren.

Alevya
quelle
Tippfehler: Ihre Blockgröße ist 328 und nicht 326. Willkommen bei CGCC!
Robin Ryder
Schöner Ort, danke!
Alevya,
@JoKing Nicht sicher, wie ich das verpasst habe! Wie es ist, habe ich es so geroutet, dass die zweite Hälfte keine überschüssigen Zeichen enthält, und habe einen Weg gefunden, die erste Hälfte ohne zusätzliches Leerzeichen aufzufüllen. Sieht sowieso so besser aus;)
Alevya
3

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 n2×4=2n; Die doppelte Version berechnetn2×n2×4=n2.

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.

Robin Ryder
quelle
3

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.

Giuseppe
quelle
2

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
Andrei Odegov
quelle
1
Leider müssen Sie eine Blockgröße haben, die Ihren Code in gleiche Blöcke unterteilt. Wie im fraglichen Beispiel über Primlängenlösungen.
John Rees
@ JohnRees, ich habe meine Antwort korrigiert, danke.
Andrei Odegov
1

Perl 5 ( -p), 22 15 Bytes

-7 Bytes dank Grimy

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

TIO

Nahuel Fouilleul
quelle
15: TIO
Grimmy
Als ich Ihre Lösung ansah, hatte ich gerade eine 22-Byte-Lösung gefunden
Nahuel Fouilleul,
verstanden, zuerst Eingabe * = 2, dann durch Eingabe * = Eingabe / 4
Nahuel Fouilleul
weitere 16 Bytes (-a)$_*=/@F/?2:$_/4;
Nahuel Fouilleul
Bis auf 8 (als separate Antwort gepostet, da es sehr unterschiedlich ist).
Grimmy
1

Kohle , 13 Bytes

PI×Iθ⎇υIθ²⊞υω

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);.

Neil
quelle
1

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.

Kevin Cruijssen
quelle
1

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.

Zottelig
quelle
1

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.

val sagt Reinstate Monica
quelle
1
40,
Blockgröße
1

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.

Jona
quelle
1

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!

Matthew Jensen
quelle
1

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)
Scherzen
quelle
0

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).

GammaFunktion
quelle