Räuber Abschnitt

Die Cops-Sektion finden Sie hier .

Herausforderung

Ihre Aufgabe ist es, die Beiträge der Bullen in derselben Sprache und derselben Version zu übertreiben (z. B. Python 3.5 ≠ Python 3.4 , so dass dies nicht zulässig ist). Eine Übermittlung ist übertrieben, wenn die Länge in Bytes kürzer als die ursprüngliche Übermittlung ist. Sie müssen nur mindestens 1 Byte abwerfen, um eine Einreichung zu knacken. ZB wenn die Aufgabe darin bestand, 2 × n auszuführen , und die Vorlage die folgende war:

print(2*input())

Sie könnten den Cop überraschen, indem Sie Folgendes tun:

print 2*input()

Oder auch das (da Lambdas erlaubt sind):

lambda x:2*x

Veröffentliche dies mit dem folgenden Header:

##{language name}, <s>{prev byte count}</s> {byte count}, {cop's submission + link}

Zum Beispiel:

Python 2, 16 12 Bytes, Adnan (+ Link zur Einreichung)

lambda x:2*x

Berechnet A005843 (Offset = 0).

In diesem Fall haben Sie die Übermittlung geknackt .

Wertung

Die Person, die die meisten Einsendungen geknackt hat, ist der Gewinner.

Regeln

• Die Crack-Einreichung muss in derselben Sprache wie die Cop-Einreichung sein.
• Dieselbe Eingabe sollte zur selben Ausgabe führen (also sollte a (2) = 4 4 bleiben).
• Für Sprachen wie Python können Sie Bibliotheken importieren, die standardmäßig in der Sprache enthalten sind. (Also, keine Numpy / Sympy etc.)
• Eingabe und Ausgabe erfolgen beide dezimal (Basis 10).

Hinweis

Diese Herausforderung ist beendet. Der Gewinner der Räuber- Sektion ist feersum . Die endgültigen Ergebnisse für den CnR sind nachstehend aufgeführt:

• Feersum : 16 Risse
• Dennis : 12 Risse
• Undichte Nonne : 6 Risse
• Lynn : 4 Risse
• Meilen : 3 Risse
• Martin Ender : 2 Risse
• Emigna : 2 Risse
• jimmy23013 : 1 Riss
• Sp3000 : 1 Riss
• zufällig : 1 Riss
• Alephalpha : 1 Riss
• nimi : 1 Riss
• Zerstörbare Wassermelone : 1 Riss
• Dom Hastings : 1 Riss

Cheddar, 7 6 Bytes, Downgoat

(<<)&1

Dies scheint zu funktionieren, aber es ist immer möglich, dass ich die Sprache nicht richtig verstehe.

Gelee ,54 Bytes , George V. Williams

RÆḊḞ

Probieren Sie es hier aus.

Ein verstecktes Feature!

Wenn ich mich richtig erinnere, ist ÆḊ(A) = sqrt (det (AA ^T )) n! mal das n-dimensionale Lebesgue-Maß eines Simplex aus n Eingabepunkten und dem Ursprung im m-dimensionalen Raum. Wenn n = 1, degeneriert es zur euklidischen Distanz. Immerhin nicht so komisch ...

Hexagony , 91 33 Bytes, Blau

1""?{\>{+/</+'+./_'..@'~&/!}'+=($

Entfaltet:

    1 " " ?
   { \ > { +
  / < / + ' +
 . / _ ' . . @
  ' ~ & / ! }
   ' + = ( $
    . . . .

Probieren Sie es online!

Sieht immer noch ein bisschen golfen aus, aber ich dachte, ich würde es posten, bevor mich FryAmTheEggman schlägt. ;)

Erläuterung

Hier sind einige farbcodierte Ausführungspfade:

Diese sind jedoch aufgrund des Golfspiels unnötig verworren. Hier ist der exakt gleiche Code mit einem genaueren Layout:

Das ist besser. Und schließlich ist hier ein Speicherdiagramm, in dem der rote Pfeil die anfängliche Position und Ausrichtung des Speicherzeigers (MP) angibt:

Das Wesentliche ist, dass ich iterativ Fibonacci-Zahlen an den drei mit f (i) , f (i + 1) und f (i + 2) bezeichneten Kanten berechne, während ich den Iterator an den Kanten A , B und C verfolge . Dabei werden die Rollen dieser Kanten nach jeder Iteration zyklisch ausgetauscht. Mal sehen, wie das passiert ...

Der Code beginnt auf dem grauen Pfad, der einige anfängliche Einstellungen vornimmt. Beachten Sie, dass f (i) bereits den richtigen Anfangswert von hat 0.

1   Set edge f(i+1) to 1.
""  Move the MP to edge A.
?   Read input n into edge A.
)   Increment n.

Jetzt ist der grüne Weg die Hauptschleife. _und >sind nur Spiegel.

(     Decrement n.
<     If the result is zero or less, continue on the red path, otherwise
      perform another iteration of the main loop.
{     Move the MP to edge f(i+2).
+     Add edges f(i) and f(i+1) into this edge, computing the next Fibonacci number.
'     Move the MP to the edge opposite A.
~     Multiply by -1 to ensure that it's non-positive (the edge may have a positive
      value after a few iterations).
&     Copy the current value of n from A.
'     Move back and to the right again.
+     Copy n by adding it to zero. Since we know that the other adjacent edge
      is always zero, we no longer need to use ~&.
'+'+  Repeat the process twice, moving n all the way from A to B.
=     Reverse the orientation of the MP so that it points at f(i) which now
      becomes f(i+2) for the next iteration.

Auf diese Weise bewegt sich der MP um das innere Triplett von Kanten und berechnet aufeinanderfolgende Fibonacci-Zahlen, bis er nNull erreicht. Dann wird endlich der rote Pfad ausgeführt:

{}    Move the MP to f(i).
!     Print it.
@     Terminate the program.

Mit Timwis HexagonyColorer und EsotericIDE erstellte Diagramme .

Haskell, 5 4 Bytes, xnor

(^)1

Einfaches Curry.

Stapel Katzen, 14 13 Bytes, Feersum

^]T{_+:}_

mit den -nmFlags für +4 Bytes. Probieren Sie es online!

Okay, diese Schleife war verrückt. Ich habe verschiedene Ansätze ausprobiert, z. B. Brute Forcing über ein reduziertes Alphabet und Brute Forcing 3x+2oder den 5x+4Versuch, es zu erweitern, aber ich hätte nie erwartet, dass die Lösung tatsächlich eine Schleife enthält.

Der beste Weg, um zu sehen, wie dies funktioniert, besteht darin, ein DFlag zum Debuggen hinzuzufügen (also mit auszuführen -nmD) und das Debuggen für den obigen TIO-Link zu aktivieren. Eine {}Schleife merkt sich die Stapelspitze am Anfang der Schleife und wird beendet, wenn die Stapelspitze wieder diesen Wert aufweist. Im Inneren der Schleife macht es Spaß, die drei obersten Elemente des Stapels zu subtrahieren und zu wechseln. Auf diese Weise kann die Schleife für so viele Iterationen ausgeführt werden.

Sesos, 14 11 Bytes, undichte Nonne

Berechnet n ² . Probieren Sie es hier aus.

Hex-Dump:

0000000: 16c0f7 959d9b 26e83e ce3d                         ......&.>.=

Ab Montage:

set numin
set numout
get
jmp
  jmp, sub 1, fwd 1, add 1, fwd 1, add 2, rwd 2, jnz
  fwd 2, sub 1
  rwd 1, sub 1
  jmp, sub 1, rwd 1, add 1, fwd 1, jnz
  rwd 1
jnz
fwd 2
put

Woefully 776 759 Bytes, zerstörbare Wassermelone

| |||||||| | |
|| |||||| |
||| |||| |
|||| || |
||||| || |
|||| |||| |
||| |||||| |
|| |||||||| |
| |||||||||| |
|| |||||||| |
||| ||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
||||||||| |
||||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |
|| |
| |
| |
| |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |
|||||| |
||||||| |
|||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
| |
|| |
| |
|| |
||| |
||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |

Ich habe versucht, den Quellcode für diese Sprache zu lesen, aber es war zu verwirrend. Zum einen ip[1]ist eine Zeilennummer ip[0]die Spaltennummer, während die cpKoordinaten umgekehrt verwendet werden. Manchmal wird jedoch der Wert von cpzugewiesen ip. Ich habe es aufgegeben, zu verstehen, was das Programm tut, und habe einen Weg gefunden, die identische Befehlsfolge mit weniger Takten zu codieren.

Brachylog , 27 21 Bytes, Fatalize

yrb:1a:+a:[1]c*.
:2/.

Probieren Sie es online!

J, 17 12 Bytes, Meilen

+/@(]!2*-)i:

So ziemlich das gleiche wie das Original, nur mehr Golf. :)

i:mit +1Bereich im Vergleich zu i.ist nützlich (und komisch). Wenn du das i.hier verwendest n=0wird das aber zum Glück falsch gelöst i:.

Probieren Sie es hier online aus.

M, 10 6 Bytes, Dennis

R×\³¡Ṫ

Mit n wird die n- ^te Fakultät von n berechnet . Das war eine lustige Übung!

Der Code kann als Jelly ausgeführt werden, sodass Sie ihn online testen können .

Erläuterung

R×\³¡Ṫ  Input: n
R       Create the range [1, 2, ..., n]
   ³¡   Repeat n times starting with that range
 ×\       Find the cumulative products
     Ṫ  Get the last value in the list
        Return implicitly

Schneemann, 50 44 Bytes, Türknauf

((}#2nMNdE0nR1`wRaC2aGaZ::nM;aF;aM:`nS;aF*))

Probieren Sie es online!

Haskell, 15 bis 14 Bytes, xnor

until odd succ

Ich habe ein paar Stunden lang erfolglos gelernt, "sinnlose" Syntax zu entschlüsseln ... untilIch fand das stattdessen.

Oder für weniger gut aussehende 13 Bytes until odd(+1).

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3

Pyke, 11 9 Bytes, Schlammfisch

hVoeX*oe+

Probieren Sie es hier aus!

Wie es funktioniert

          Implicit input: n (accumulator), n (iterations)
h         Increment the number of iterations.
 V        Do the following n + 1 times.
  o         Iterator. Pushes its value (initially 0) and increments it.
   e        Perform integer division by 2.
            This pushes 0 the first time, then 1, then 2, etc.
    X       Square the result.
     *      Multiply the accumulator and the result.
      oe    As before.
        +   Add the result to the accumulator.
            This sets the accumulator to a(0) = 0 in the first iteration and
            applies the recursive formula in all subsequent ones.

05AB1E , 7, 4, Emigna

LnOx

Aus der Formel für die Summe der Quadrate positiver Ganzzahlen 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, wenn wir multiplizieren beidseitig zu 2 erhalten wir Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, eine alternative Formel für diese Folge. - Mike Warburton (mikewarb (AT) gmail.com), 8. September 2007

Jelly, 22 21 Bytes, Dennis

_²×c×Ḥc¥@÷⁸÷’{S
‘µR+ç

Ich habe mehrere Stunden damit verbracht, Jelly-Quellcode für den letzten zu lesen, also könnte ich diese "Fähigkeit" genauso gut anwenden. Ich hoffe, @Dennis teilt uns seine mathematischen Entdeckungen mit, die eine kürzere Formel erlauben (vorausgesetzt, es gibt etwas und nicht nur seltsame Geleetricks!).

J, 20 bis 19 Bytes, Meilen

[:+/2^~+/@(!|.)\@i.

Dies berechnet das Produkt als Summe der quadratischen Fibonacci-Zahlen, die als Summe der Binomialkoeffizienten berechnet werden.

Zum Glück hat @miles selbst den Code gepostet, um Fibonacci-Zahlen in diesem Kommentar zu generieren .

Acc !! , 526 525 Bytes, DLosc

N
Count x while _%60-46 {
(_+_%60*5-288)*10+N
}
_/60
Count i while _/27^i {
_+27^i*(_/27^i*26-18)
}
_*3+93
Count i while _/27^i/27%3 {
_-i%2*2+1
Count j while _/3^(3*j+2-i%2)%3 {
_+3^(1+i%2)
Count k while _/3^(3*k+1+i%2)%3-1 {
_+3^(3*k+1+i%2)*26
}
}
}
Count i while _/27^i/3 {
_-_/27^i/3%27*27^i*3+_/3^(3*i+1+_%3)%3*3
}
_/3
Count i while _/100^i {
_*10-(_%100^i)*9
}
Count i while _/100^i/10 {
_+_/100^i/10%10
Count j while i+1-j {
_+(_%10-_/100^(j+1)%10)*(100^(j+1)-1)
}
}
_/100
Count j while _/100^j {
Write _/100^j%10+48
}

Ich habe keine Ahnung, wie das funktioniert, aber ich konnte eine winzige Verbesserung feststellen.

24c24
< _+_/100^i*100^i*9
---
> _*10-(_%100^i)*9

Haskell, 10 Bytes, xnor

gcd=<<(2^)

Anwendungsbeispiel: map ( gcd=<<(2^) ) [1..17]-> [1,2,1,4,1,2,1,8,1,2,1,4,1,2,1,16,1].

So funktioniert es: Von der OEIS Seite wir sehen a(n) = gcd(2^n, n)oder in Haskell Syntax geschrieben: a n = gcd (2^n) n. Funktionen mit dem Muster f x = g (h x) xkönnen über die Funktion =<<: punktfrei f = g =<< hgeschaltet werden, gcd=<<(2^)was sich somit wieder in übersetzt gcd (2^x) x.

Sesos, 14 9 Bytes, undichte Nonne

Berechnet n mod 16 . Probieren Sie es hier aus.

Verhexen:

0000000: 17f84a 750e4a 7d9d0f                              ..Ju.J}..

Versammlung:

set numin
set numout
set mask
get
jmp, sub 1, fwd 1, add 16, rwd 1, jnz
fwd 1
jmp, sub 16, fwd 1, add 1, rwd 1, jnz
fwd 1
put

Python, 39 17 Bytes, Destructible Watermelon

lambda n:n*-~n>>1

05AB1E, 9 4 Bytes, Emigna

>n4÷

Probieren Sie es online!

Berechnet stattdessen diese Funktion:

Hexagony , 7 6 Bytes, Adnan

?!/$(@

Entfaltet:

 ? ! 
/ $ (
 @ .

Probieren Sie es online!

Gleiche Idee, etwas anderes Layout.

MATL, 11 10 Bytes, Luis Mendo

YftdAwg_p*

Anstelle von -1 ^ length (array) werden die Elemente in Boolesche Werte (die immer 1 sind) konvertiert, sie werden negiert und das Produkt der Elemente wird genommen.

Jelly, 11 10, Dennis

Ḥ’_Rc’*@RP

Vektorisierte Version des gleichen Ansatzes.

Probieren Sie es online!

05AB1E, 10 8 Bytes, Adnan

µNÂÂQ>i¼

Probieren Sie es online aus .

Brachylog, 11 bis 10 Bytes, Fatalize

yb:AcLrLc.

Probieren Sie es online!

Erläuterung

Brachylog ist eine von Prolog abgeleitete Sprache, deren größte Fähigkeit darin besteht, Dinge zu beweisen.

Hier beweisen wir diese Aussagen:

yb:AcLrLc.
yb:AcL       Inclusive range from 1 to input, concatenated with A, gives L
     LrL     L reversed is still L
       Lc.   L concatenated is output

Jelly, 9 8 Bytes, Dennis

œċr0$L€Ḅ

Es tut uns leid! Ich konnte Ihre beabsichtigte Lösung nicht finden.

Dies beruht auf der Tatsache, dass C(n+k-1, k)die Anzahl der Auswahlmöglichkeiten für kWerte nbeim Ersetzen festgelegt ist.

Hinweis: Dies ist ineffizient, da die möglichen Mengen generiert werden, um sie zu zählen. Vermeiden Sie daher die Verwendung großer Werte von n online.

Probieren Sie es online aus oder überprüfen Sie bis zu n .

Ich habe später eine weitere 8-Byte-Version gefunden, die effizient genug ist, um n = 1000 zu berechnen . Dadurch werden die Werte unter Verwendung des Binomialkoeffizienten berechnet, und es wird vermieden, die Listen zu generieren.

Ḷ+c’Ṛ;1Ḅ

Probieren Sie es online aus oder überprüfen Sie bis zu n .

Erläuterung

œċr0$L€Ḅ  Input: n
  r0$     Create a range [n, n-1, ..., 0]
œċ        Create all combinations with replacement for
          (n, n), (n, n-1), ..., (n, 0)
     L€   Find the length of each
       Ḅ  Convert it from binary to decimal and return

Ḷ+c’Ṛ;1Ḅ  Input: n
Ḷ         Creates the range [0, 1, ..., n-1]
 +        Add n to each in that range
   ’      Get n-1
  c       Compute the binomial coefficients between each
    Ṛ     Reverse the values
     ;1   Append 1 to it
       Ḅ  Convert it from binary to decimal and return

M, 9 8 Bytes, Dennis

Ḥrc’ḊḄḤ‘

QBasic, 30 bis 29 Bytes, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2