Enumerazione intera vertiginosa

25

La tua sfida oggi è produrre un determinato termine di una sequenza che elenca tutti gli interi. La sequenza è la seguente: Se abbiamo una funzione con indice 0 che genera la sequenza f(n)ed ceil(x)è la funzione soffitto, allora f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))è positivo quando ne ceil(n/2)sono entrambi pari o entrambi dispari.

Per aiutare a comprendere questa sequenza, i primi termini sono i seguenti: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Il tuo compito è scrivere un programma che impieghi un numero intero ne produca il ntermine della sequenza. L'ingresso può essere solo 0 o 1 indicizzato.

Casi di test (indicizzati 0):

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

Questo è code-golf , vince meno byte!

code-golf  sequence  integer 
— Pavel
fonte
— sergiol,
Sembra l'inverso di una funzione di piegatura
— sergiol

Risposte:

8

SOGL V0.12 , 8 6 byte

I».»⌡±

Provalo qui! oppure prova i primi numeri di coppia (modificati un po 'in modo che funzionino)
indicizzati a 0.

Spiegazione:

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

O più semplice:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡
— dzaima
fonte
3
NON DIVENTA UN SOLO MINUTO!
— NieDzejkob,
6
Io ».»sono al telefono I».»⌡±.
— Jonathan Allan,
@JonathanAllan Non capisco ._.
— Pavel,
4

C, 25 byte

f(n){return~n/2*~-(n&2);}
— orlp
fonte
È possibile salvare 4 byte assegnando il valore restituito al primo parametro anziché utilizzare la parola chiave return. f(n){n=~n/2*~-(n&2);}
— Cleblanc,
5
@cleblanc Non è così che funziona C.
— orlp,
2
gcc -O0per x86-64 capita di compilare la versione di @ cleblanc in istruzioni che lasciano il risultato moltiplicare in eax( godbolt.org/g/dztKPV ), ma poi sarebbe una x86-64 gcc -O0risposta, non una risposta in C. Non voto a favore delle risposte C che si rompono con l'ottimizzazione abilitata, soprattutto non quella stupida ultima espressione come merda del valore di ritorno. Anche se è così che gcc funziona, non è così che funziona C.
— Peter Cordes,
Crea un puntatore. Non hai bisogno di ottimizzazioni se i valori originali e finali non sono nello stack.
— mreff555,
1
@ mreff555 Sarebbe un metodo IO non standard (sebbene accettabile) e non sarebbe più breve.
— orlp,
3

Pyke , 6 byte

heQeV_

Provalo qui!

Usa l'approccio di dzaima ... Beats Ties Jelly!

Spiegazione

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

I byte esadecimali codificati equivalenti sarebbero: 68 65 51 65 56 5F.

— Mr. Xcoder
fonte
3

Mathematica, 24 byte

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

-14 byte da @Misha Lavrov

— J42161217
fonte
1
L'uso Boolee OddQha l'effetto di convertire i numeri dispari in 1 e i numeri pari in 0, ma non è necessario qui: i poteri di -1 ti danno comunque la risposta giusta per tutti i numeri dispari. Quindi puoi ridurre questo passaggio (-1)^Tr@{#,s}o semplicemente (-1)^(#+s).
— Misha Lavrov,
3

Haskell , 25 43 42 byte

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

Provalo online! 1-indicizzati.

Modifica: la versione precedente aveva i segni in un ordine sbagliato, grazie a @ Potato44 per averlo sottolineato. Risolto per 18 byte ...

Modifica 2: Grazie a BMO per -1 byte!

— Laikoni
fonte
Puoi salvare 1 byte usando la notazione, provalo online!
— ბიმო
@BMO Grazie! ...
— Laikoni,
2

Lotto, 29 byte

@cmd/cset/a"%1/2^(%1<<30>>30)
— Neil
fonte
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
Espandi frammento

0-indicizzati.

— Neil
fonte
2

Javascript, 17 byte

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

Mostra snippet di codice

Questo è 0 indicizzato. È un trucco del tutto bitally.

— ricorsivo
fonte
2

cubica , 23 byte

(1-indicizzati)

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

Provalo online!

Le principali difficoltà quando si scrive il codice in Cubically sono:

  • Esiste solo 1 variabile scrivibile e
  • Ottenere costanti è difficile.

Quindi, questa soluzione calcola

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

dove / indica la divisione intera. Ciò richiede solo 1 variabile temporanea e costanti 1 e 2.

Spiegazione:

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
fonte
2

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

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

Un programma completo che si chiama like 5:prgmNAME.

TI-Basic è un lanugage tokenizzato , tutti i token utilizzati qui sono un byte, tranne per il remainder(quale due. ‾rappresenta il token regativo, che viene digitato con la (-)chiave.

Esempi:

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

Spiegazione:

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

Stessa formula di una funzione Y-var:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2
— pizzapants184
fonte
2

dc , 16 byte

1+d2~+2%2*1-r2/*

Sono sicuro che c'è un modo per ridurre da 0..1 a -1..1 in cc, ma per ora nessuna idea.

Provalo online!

— cab404
fonte
2

Java 8, 15 byte

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

EDIT: Java è davvero il più breve dei linguaggi non golfistici ?! ò.ò

Spiegazione:

Provalo qui.

Userò la tabella qui sotto come riferimento di ciò che sta accadendo.

  1. ~nè uguale a -n-1.
  2. Poiché la divisione dei numeri interi in Java si basa automaticamente su numeri interi positivi e ceils su numeri interi negativi, si ~n/2otterrà la sequenza0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
  3. n&2comporterà una 0o 2, nella sequenza0,0,2,2,0,0,2,2,0,0,2,...
  4. ~-xè uguale a (x-1), quindi ~-(n&2)( ((n&2)-1)) risulta nella sequenza-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
  5. Moltiplicare le due sequenze di ~n/2e ~-(n&2)dà è la sequenza corretta richiesta nella sfida:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Tabella panoramica:

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
fonte
2

Brain-Flak , 86 74 72 70 byte

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

Provalo online!

Spiegazione

Ci sono due parti in questo codice. La prima parte

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

fa la forza del calcolo. Determina ceil(n/2)e se negare o meno l'output.

Per spiegare come funziona spiegherò prima come si calcolerebbe ceil(n/2). Questo potrebbe essere fatto con il seguente codice

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

Questo alla rovescia da n ogni volta che esegue un non (([{}]()) ) su un contatore e aggiunge il contatore a un risultato. Poiché il contatore è zero la metà del tempo, incrementiamo solo ogni altra corsa a partire dalla prima.

Ora voglio anche calcolare il segno dei nostri risultati. Per fare questo iniziamo un altro contatore. Questo contatore cambia stato solo se il primo contatore è spento. In questo modo otteniamo lo schema desiderato. Mettiamo questi due segnalini in pila per facilitarne lo spostamento quando arriva il momento.

Ora, una volta terminato quel calcolo, il nostro stack appare così

          parity(n)
ceil(n/2) sign

Quindi abbiamo bisogno di fare un po 'di lavoro per ottenere il risultato previsto, questa seconda parte lo fa.

<>{}{<>([{}])(<>)}<>
— Mago del grano
fonte
1

QBIC , 27 26 byte

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

Spiegazione

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
fonte
1

Clojure 122 byte

Verbose, anche se golfato. Vado per il voto di simpatia qui ... :-)

golfed:

(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 - Ripristina Monica
fonte
1

Excel VBA a 32 bit, 39 37 byte

Funzione di finestra immediata VBE anonima che accetta input dalla cella A1e output nella finestra immediata di VBE

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

Limitato a 32 bit in quanto A^Bnon valido in 64 bit ( A ^Bè il più vicino possibile)

— Taylor Scott
fonte
Lo spazio tra (-1)e è ^[Intnecessario?
— Pavel,
@Pavel almeno per la versione a 64 bit di Excel VBA, sì; Detto questo, giuro che non funziona con la versione a 32 bit, ma purtroppo non posso provarlo su nessuno dei componenti hardware che ho a disposizione
— Taylor Scott
@Pavel - L'ho visto in un sistema a 32 bit (specifica di installazione predefinita) e in quel sistema lo spazio non è richiesto - Ho limitato la soluzione a 32 bit per sfruttare questo
— Taylor Scott
1
Freddo! Tuttavia, hai dimenticato di aggiungere il conteggio dei byte corretti.
— Pavel
Whoops, Thanks @Pavel - Ora è risolto
— Taylor Scott
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.