Dizzy Integer Enumeration

25

Ihre heutige Herausforderung besteht darin, einen bestimmten Term einer Sequenz auszugeben, in der alle ganzen Zahlen aufgelistet sind. Die Folge ist wie folgt: Wenn wir eine 0-indizierte Funktion haben, die die Folge erzeugt f(n)und ceil(x)die Deckenfunktion ist, dann f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))ist positiv, wenn nund ceil(n/2)entweder beide gerade oder beide ungerade sind.

Zum besseren Verständnis dieser Abfolge lauten die ersten Begriffe wie folgt: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Ihre Aufgabe ist es, ein Programm zu schreiben, das eine ganze Zahl annimmt nund den ndritten Term der Sequenz ausgibt . Die Eingabe kann nur 0- oder 1-indiziert sein.

Testfälle (0-indiziert):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

Das ist Code-Golf , die wenigsten Bytes gewinnen!

code-golf  sequence  integer 
— Pavel
quelle
— Siehe auch
Es scheint die Umkehrung einer Folding-Funktion
— Sergiol

Antworten:

8

SOGL V0.12 , 8 6 Bytes

I».»⌡±

Probieren Sie es hier aus! oder versuchen Sie es mit den ersten paar Zahlen (etwas geändert, damit es funktioniert), die mit
0 indiziert sind.

Erläuterung:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Oder einfacher:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡
— dzaima
quelle
3
ES HAT KEINE MINUTE GENOMMEN!
— NieDzejkob
6
Ich ».»bin am Telefon I».»⌡±.
— Jonathan Allan
@ JonathanAllan Ich verstehe es nicht.
— Pavel
4

C 25 Bytes

f(n){return~n/2*~-(n&2);}
— orlp
quelle
Sie können 4 Bytes sparen, indem Sie den Rückgabewert dem ersten Parameter zuweisen, anstatt das Schlüsselwort return zu verwenden. f(n){n=~n/2*~-(n&2);}
— Cleblanc
5
@cleblanc So funktioniert C nicht.
— Orlp
2
gcc -O0for x86-64 kompiliert @ cleblancs Version mit Anweisungen, die das Multiplikationsergebnis hinterlassen eax( godbolt.org/g/dztKPV ), aber dann wäre es eine x86-64 gcc -O0Antwort, keine C-Antwort. Ich stimme C-Antworten, die mit aktivierter Optimierung brechen, nicht herauf, besonders nicht diesen blöden letzten Ausdruck als Rückgabewert-Mist. Selbst wenn gcc so funktioniert, funktioniert C nicht so .
— Peter Cordes
Machen Sie einen Zeiger. Sie brauchen keine Optimierungen, wenn sich der ursprüngliche und der endgültige Wert nicht auf dem Stapel befinden.
— Treff555
1
@ mreff555 Das wäre eine nicht standardmäßige (obwohl akzeptable) E / A-Methode und würde nicht kürzer sein.
— Orlp
3

Mathematica, 24 Bytes

(s=⌈#/2⌉)(-1)^(#+s)&

-14 Bytes von @Misha Lavrov

— J42161217
quelle
1
Wenn Sie Booleund verwenden OddQ, werden ungerade Zahlen in 1 und gerade Zahlen in 0 konvertiert, aber das brauchen Sie hier nicht: Potenzen von -1 geben Ihnen ohnehin die richtige Antwort für alle ungeraden Zahlen. So können Sie diesen Schritt auf (-1)^Tr@{#,s}oder nur reduzieren (-1)^(#+s).
— Mischa Lawrow
2

Batch, 29 Bytes

@cmd/cset/a"%1/2^(%1<<30>>30)
— Neil
quelle
2

JavaScript (ES6), 18 Byte

f=
n=>n/2^(n<<30>>30)
<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0
Erweitern Sie das Snippet

0-indiziert.

— Neil
quelle
2

Javascript, 17 Bytes

n=>~n/2*~-(n&2)^0

Code-Snippet anzeigen

Dieser ist 0 indiziert. Es ist ein rein bitweiser Trick.

— rekursiv
quelle
2

Kubisch 23 Bytes

(1-indiziert)

FDF'$:7+8/0_0*0-8*7/0%6

Probieren Sie es online!

Die Hauptschwierigkeiten beim Schreiben von Code in Cubically sind:

  • Es gibt nur 1 schreibbare Variable und
  • Konstanten abrufen ist schwer.

Also diese Lösung berechnen

((((n+1)/2)%2)*2-1)*n/2

woher / bezeichnet eine ganzzahlige Division. Das braucht nur 1 temporäre Variable und die Konstanten 1 und 2.

Erläuterung:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print
— user202729
quelle
2

TI-Basic (TI-84 Plus CE), 20 Byte

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Ein volles Programm, das gerne aufgerufen wird 5:prgmNAME.

TI-Basic ist eine Token-Sprache . Alle hier verwendeten Token bestehen aus einem Byte, mit Ausnahme von remainder(zwei. ‾Stellt das mit dem (-)Schlüssel eingegebene Token dar .

Beispiele:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Erläuterung:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Gleiche Formel wie eine Y-Var-Funktion:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2
— Pizzapants184
quelle
2

Java 8, 15 Bytes

n->~n/2*~-(n&2)

EDIT: Ist Java wirklich die kürzeste der Nicht-Golf-Sprachen ?! o.Ô.

Erläuterung:

Probieren Sie es hier aus.

Ich werde die folgende Tabelle als Referenz für das verwenden, was passiert.

  1. ~nist gleich -n-1.
  2. Da die Ganzzahldivision in Java automatisch positive Ganzzahlen und Ceils negative Ganzzahlen überschreibt, ~n/2ergibt sich die Reihenfolge0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
  3. n&2ergibt entweder 0oder 2, in der Reihenfolge0,0,2,2,0,0,2,2,0,0,2,...
  4. ~-xist gleich (x-1), so ergibt ~-(n&2)( ((n&2)-1)) die Folge-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
  5. Das Multiplizieren der beiden Sequenzen von ~n/2und ~-(n&2)ergibt die richtige Sequenz, die in der Challenge abgefragt wurde:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Übersichtstabelle:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5
— Kevin Cruijssen
quelle
2

Brain-Flak , 86 74 72 70 Bytes

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

Probieren Sie es online!

Erläuterung

Dieser Code besteht aus zwei Teilen. Der erste Teil

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

erledigt die Berechnung. Sie bestimmt, ceil(n/2)ob der Ausgang negiert werden soll oder nicht.

Um zu erklären, wie es funktioniert, erkläre ich zunächst, wie man rechnen würde ceil(n/2). Dies könnte mit dem folgenden Code erfolgen

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

Dies zählt von n jedes Mal herunter, wenn es eine nicht (([{}]()) ) für einen Zähler und fügt den Zähler zu einem Ergebnis hinzu. Da der Zähler die Hälfte der Zeit null ist, erhöhen wir nur jeden zweiten Lauf, beginnend mit dem ersten.

Jetzt möchte ich auch das Vorzeichen unserer Ergebnisse berechnen. Dazu starten wir einen weiteren Zähler. Dieser Zähler ändert nur den Zustand, wenn der erste Zähler ausgeschaltet ist. Auf diese Weise erhalten wir das gewünschte Muster. Wir legen diese beiden Marken auf den Stapel, um sie später leichter bewegen zu können.

Nachdem wir diese Berechnung abgeschlossen haben, sieht unser Stapel folgendermaßen aus

          parity(n)
ceil(n/2) sign

In diesem zweiten Teil müssen wir also einige Arbeiten durchführen, um das gewünschte Ergebnis zu erzielen.

<>{}{<>([{}])(<>)}<>
— Weizen-Assistent
quelle
1

QBIC , 27 26 Bytes

g=(:+1)'\2`~(a-g)%2|?-g\?g

Erläuterung

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g
— steenbergh
quelle
1

Clojure 122 Bytes

Ausführlich, auch beim Golfen. Ich werde hier für die Sympathie-Abstimmung gehen ... :-)

Golf gespielt:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Ungolfed:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))
— Bob Jarvis - Setzen Sie Monica wieder ein
quelle
1

Excel VBA 32-Bit, 39 37 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben von der Zelle A1und Ausgaben in das VBE-Direktfenster übernimmt

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Beschränkung auf 32-Bit, da A^Bin 64-Bit nicht gültig ( A ^Bso nah wie möglich)

— Taylor Scott
quelle
Ist der Raum zwischen (-1)und ^[Intbenötigt?
— Pavel
@Pavel zumindest für die 64-Bit-Version von Excel VBA, ja; Aber das heißt, ich schwöre, dass es nicht für die 32-Bit-Version gilt, aber leider kann ich das auf keiner der Hardware testen, die ich zur Hand habe
— Taylor Scott
@Pavel - Ich habe es mir unter einem 32-Bit-System angesehen (Standardinstallationsspezifikation) und unter diesem System ist der Speicherplatz nicht erforderlich - Ich habe die Lösung auf 32-Bit beschränkt, um dies zu nutzen
— Taylor Scott
1
Cool! Sie haben jedoch vergessen, die korrigierte Byteanzahl hinzuzufügen.
— Pavel
Whoops, Thanks @Pavel - Es ist jetzt behoben
— Taylor Scott
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.