Séquence de signes alternée

16

introduction

Le signe d'un nombre est soit a +, soit a -pour chaque entier non nul. Zéro lui-même est sans signe ( +0est le même que -0). Dans la séquence suivante, nous allons alterner entre le signe positif , le zéro et le signe négatif . La séquence commence par 1, donc nous écrivons 1avec un signe positif, avec zéro (celui-ci est bizarre, mais nous multiplions simplement le nombre par 0) et le signe négatif:

1, 0, -1

Le numéro suivant est 2, et nous faisons à nouveau la même chose:

2, 0, -2

La séquence est finalement:

1, 0, -1, 2, 0, -2, 3, 0, -3, 4, 0, -4, 5, 0, -5, 6, 0, -6, 7, 0, -7, ...

Ou une forme plus lisible:

a(0) = 1
a(1) = 0
a(2) = -1
a(3) = 2
a(4) = 0
a(5) = -2
a(6) = 3
a(7) = 0
a(8) = -3
a(9) = 4
...

La tâche

Étant donné un entier non négatif n , sortez le n ème terme de la séquence ci-dessus. Vous pouvez choisir si vous utilisez la version à index zéro ou à index unique .

Cas de test:

Zéro indexé:

a(0) = 1
a(11) = -4
a(76) = 0
a(134) = -45
a(296) = -99

Ou si vous préférez un indexé:

a(1) = 1
a(12) = -4
a(77) = 0
a(135) = -45
a(297) = -99

C'est du , donc la soumission avec le plus petit nombre d'octets gagne!

Adnan
la source
Est-ce que ça va si vous commencez[0, 0, 0, -1, 0, 1...
Bleu
@muddyfish non désolé, il faut commencer par 1.
Adnan

Réponses:

6

Gelée, 7 octets

+6d3’PN

Zéro indexé. Cas de test ici.

Explication:

+6      Add 6:     x+6
d3      Divmod:    [(x+6)/3, (x+6)%3]
’       Decrement: [(x+6)/3-1, (x+6)%3-1]
P       Product    ((x+6)/3-1) * ((x+6)%3-1)
Lynn
la source
6

JavaScript ES6, 18 octets

n=>-~(n/3)*(1-n%3)

Il s'est avéré très similaire à la réponse de @ LeakyNun, mais je ne l'ai vue qu'après avoir posté la mienne.

Explication et non golfé

-~ est un raccourci pour Math.ceil ou un arrondi:

n =>               // input in var `n`
    Math.ceil(n/3) // Get every 3rd number 1,1,1,2,2,2, etc.
    *
    (1-n%3)        // 1, 0, -1, 1, 0, -1, ...

Downgoat
la source
1
(J'atteste par la présente qu'il n'a pas vu ma solution avant de poster sa solution)
Leaky Nun
Math.ceilet -~sont différents; Math.ceil(1) == 1alors que-~1 == 2
Cyoce
1
1 octet plus court:n=>~(n/3)*~-(n%3)
Cyoce
6

MarioLANG, 93 81 octets

un index

Essayez-le en ligne

;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

Explication:

on commence par prendre l'imput

;

qui nous donne

          v
... 0 0 input 0 0 ...

nous décrémentons ensuite l'octet gauche et incrémentons l'octet droit avec

;(-))+(
=======

on se retrouve avec

           v
... 0 -1 input +1 0 ...

nous avons ensuite mis en place la boucle

;(-))+(-
"============<
>  ![< ![<  ![
   #=" #="  #=
!  < !-< !- <
#==" #=" #=="

la boucle ira jusqu'à ce que la mémoire ressemble

         v 
... 0 -X 0 +X 0 ...

il suffit alors de sortir le résultat

;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="
Grenouille éthérée
la source
2
Agréable! Vous semblez aimer MarioLang.
Rɪᴋᴇʀ
@EasterlyIrk Cependant, le sentiment ne semble pas réciproque de MarioLang à EtherFrog: ;(et >:(. Bien que, deux fois, [<:on puisse considérer un peu heureux. ; P
Kevin Cruijssen
4

Python 2, 24 octets

lambda n:(n/3+1)*(1-n%3)

Programme complet:

a=lambda n:(n/3+1)*(1-n%3)

print(a(0))   #   1
print(a(11))  #  -4
print(a(76))  #   0
print(a(134)) # -45
print(a(296)) # -99
Leaky Nun
la source
4

MATL, 15 12 octets

3/XkG3X\2-*_

Cela utilise une indexation basée sur un.

Essayez-le en ligne! ou vérifier les cas de test

Explication:

    G          #Input
     3X\       #Modulus, except multiples of 3 give 3 instead of 0
        2-     #Subtract 2, giving -1, 0 or 1
3/Xk           #Ceiling of input divided by 3.
          *    #Multiply 
           _   #Negate
DJMcMayhem
la source
Pour s'occuper de la plupart des problèmes, quelque chose comme ça Q3/Xk-1:1G_)*pourrait mieux fonctionner. Il peut probablement être modifié à la place pour une indexation basée sur 1.
Suever
4

Haskell, 27 octets

f x=div(x+3)3*(1-mod(x+3)3)

Solution 28 octets légèrement plus intéressante:

(((\i->[i,0,-i])=<<[1..])!!)

(Les deux sont 0indexés)

Michael Klein
la source
3

MATL , 8 octets

:t~y_vG)

Le résultat est basé sur 1.

Essayez-le en ligne!

Explication

Cela construit le tableau 2D

 1  2  3  4  5 ...
 0  0  0  0  0 ...
-1 -2 -3 -4 -5 ...

puis utilise l'indexation linéaire pour extraire le terme souhaité. Des moyens d'indexation linéaire index vers le bas, puis à travers (donc dans le tableau ci - dessus les premières entrées de commande linéaire sont 1, 0, -1, 2, 0, ...)

:     % Vector [1 2 ... N], where N is implicit input
t~    % Duplicate and logical negate: vector of zeros
y_    % Duplicate array below the top and negate: vector [-1 -2 ... -N]
v     % Concatenate all stack contents vertically
G)    % Index with input. Implicit display
Luis Mendo
la source
3

Perl 5, 22 octets

21 plus un pour -p:

$_=(-$_,$_+2)[$_%3]/3

Utilise l'indexation basée sur 1.

Explication:

-pdéfinit la variable $_égale à l'entrée. Le code le fixe alors égal au $_%3e élément, divisé par 3, de la liste basée sur 0 (-$_,$_+2)(où %est modulo). Notez que si $_%3est deux, alors il n'y a pas un tel élément, et la division suivante par 3 numérote l'indéfini à 0. -ppuis imprime $_.

msh210
la source
3

Bash, 28 25 octets

echo $[(1+$1/3)*(1-$1%3)]
rexkogitans
la source
@DigitalTrauma, tkx, ne savait pas cela ...
rexkogitans
2

Perl 6 ,  26  23 octets

{({|(++$,0,--$)}...*)[$_]}
{($_ div 3+1)*(1-$_%3)}

(Le plus court a été traduit à partir d'autres réponses)

Explication (de la première):

{ # bare block with implicit parameter 「$_」
  (

    # start of sequence generator

    { # bare block
      |(  # slip ( so that it flattens into the outer sequence )
        ++$, # incrementing anon state var =>  1, 2, 3, 4, 5, 6
        0,   # 0                           =>  0, 0, 0, 0, 0, 0
        --$  # decrementing anon state var => -1,-2,-3,-4,-5,-6
      )
    }
    ...  # repeat
    *    # indefinitely

    # end of sequence generator

  )[ $_ ] # get the nth one (zero based)
}

Tester:

#! /usr/bin/env perl6
use v6.c;
use Test;

# store it lexically
my &alt-seq-sign = {({|(++$,0,--$)}...*)[$_]}
my &short-one = {($_ div 3+1)*(1-$_%3)}

my @tests = (
    0 =>   1,
   11 =>  -4,
   76 =>   0,
  134 => -45,
  296 => -99,
  15..^30  => (6,0,-6,7,0,-7,8,0,-8,9,0,-9,10,0,-10)
);

plan @tests * 2 - 1;

for @tests {
  is alt-seq-sign( .key ), .value, 'alt-seq-sign  ' ~ .gist;

  next if .key ~~ Range; # doesn't support Range as an input
  is short-one(    .key ), .value, 'short-one     ' ~ .gist;
}
1..11
ok 1 - alt-seq-sign  0 => 1
ok 2 - short-one     0 => 1
ok 3 - alt-seq-sign  11 => -4
ok 4 - short-one     11 => -4
ok 5 - alt-seq-sign  76 => 0
ok 6 - short-one     76 => 0
ok 7 - alt-seq-sign  134 => -45
ok 8 - short-one     134 => -45
ok 9 - alt-seq-sign  296 => -99
ok 10 - short-one     296 => -99
ok 11 - alt-seq-sign  15..^30 => (6 0 -6 7 0 -7 8 0 -8 9 0 -9 10 0 -10)
Brad Gilbert b2gills
la source
2

J, 19 15 octets

>.@(%&3)*1-3|<:

Probablement besoin de jouer au golf plus loin ...

1 indexé.

Non golfé:

>> choose_sign      =: 1-3|<:      NB. 1-((n-1)%3)
>> choose_magnitude =: >.@(%&3)    NB. ceil(n/3)
>> f                =: choose_sign * choose_magnitude
>> f 1 12 77
<< 1 _4 0

>>signifie entrée (STDIN) et <<sortie (STDOUT).

Leaky Nun
la source
2

Pyke, 8 7 octets (ancienne version)

3.DeRt*

Essayez-le ici! - Notez que le lien ne durera probablement pas longtemps

3.D      - a,b = divmod(input, 3)
   e     - a = ~a -(a+1)
     t   - b -= 1
      *  - a = a*b
         - implicit output a

Version la plus récente

3.DhRt*_

Essayez-le ici!

3.D      - a,b = divmod(input, 3)
   h     - a+=1
     t   - b-=1
      *  - a = a*b
       _ - a = -a
         - implicit output a
Bleu
la source
Pouvez-vous fournir un lien vers (ancienne version)
Downgoat
Dernier commit où l'ancien code fonctionne ici (c'est plus tôt dans la journée)
Blue
2

J, 27 octets

Bien que n'étant pas le plus golfique, je l'aime mieux, car il utilise un agenda.

>.@(>:%3:)*1:`0:`_1:@.(3|])

En voici la décomposition arborescente:

         ┌─ >.      
  ┌─ @ ──┤    ┌─ >: 
  │      └────┼─ %  
  │           └─ 3: 
  ├─ *              
──┤           ┌─ 1: 
  │      ┌────┼─ 0: 
  │      │    └─ _1:
  └─ @. ─┤          
         │    ┌─ 3  
         └────┼─ |  
              └─ ]  

Ceci est très similaire à la réponse J de Kenny, en ce sens qu'il choisit l'ampleur et le signe, mais c'est différent en ce que j'utilise un agenda pour choisir le signe.

Conor O'Brien
la source
2

MATL, 8 octets

_3&\wq*_

Cette solution utilise l'indexation basée sur 1 dans la séquence.

Essayez-le en ligne

Version modifiée montrant tous les cas de test

Explication

        % Implicitly grab the input
_       % Negate the input
3&\     % Compute the modulus with 3. The second output is floor(N/3). Because we negated
        % the input, this is the equivalent of ceil(input/3)
w       % Flip the order of the outputs
q       % Subtract 1 from the result of mod to turn [0 1 2] into [-1 0 1]
*       % Take the product with ceil(input/3)
_       % Negate the result so that the sequence goes [N 0 -N] instead of [-N 0 N]
        % Implicitly display the result
Suever
la source
2

Pyth, 10 octets

*h/Q3-1%Q3

Essayez-le en ligne!

Explication:

*     : Multiply following two arguments
h/Q3  : 1 + Input/3
-1%Q3 : 1 - Input%3

Remarque: J'ai supposé la séquence indexée zéro.

John Red
la source
1
Vous aimeriez probablement inclure ce lien. Bienvenue également à PPCG!
Leaky Nun
Je suis assez proche de votre solution ...*@(1ZtZ)%Q3h/Q3
FliiFe
@FliiFe (1ZtZ)=-L1 2
Leaky Nun
2

En fait, 10 octets

3@│\u)%1-*

Essayez-le en ligne!

Explication:

3@│\u)%1-*
3@│         push 3, swap, duplicate entire stack ([n 3 n 3])
   \u)      floor division, increment, move to bottom ([n 3 n//3+1])
      %1-   mod, subtract from 1 ([1-n%3 n//3+1])
         *  multiply ([(1-n%3)*(n//3+1)])
Mego
la source
2

05AB1E, 7 octets

Code:

(3‰`<*(

Expliqué:

(           # negate input: 12 -> -12
 3‰         # divmod by 3: [-4, 0]
   `        # flatten array: 0, -4
    <       # decrease the mod-result by 1: -1, -4
     *      # multiply: 4
      (     # negate -4
Emigna
la source
2

GeoGebra, 44 octets

Element[Flatten[Sequence[{t,0,-t},t,1,n]],n]

nest un indexé.

Explication:

Element[                      , n] # Return the nth element of the list                  .
 Flatten[                    ]     # Strip all the unnecessary braces from the list     /|\
  Sequence[{t,0,-t}, t, 1, n]      # Generate a list of lists of the form {t, 0, -t}     |
                             # This list will start with {1,0,-1} and end with {n,0,-n}  |

Il n'est pas nécessaire de générer tous les triplets {n, 0, -n}, mais c'est plus court que d'écrire ceil(n/3)ou quelque chose à cet effet. Notez qu'il ndoit être défini pour créer cet objet (s'il n'est pas défini au moment de son exécution, GeoGebra vous demandera de créer un curseur pour n).

Joe
la source
Salut et bienvenue à PPCG! Avez-vous un lien que je peux tester (de préférence en ligne)?
Rɪᴋᴇʀ
@ EᴀsᴛᴇʀʟʏIʀᴋ, merci! Voici un lien vers une applet en ligne thingamabob. La page a semblé vierge pendant un petit moment, mais ensuite elle est apparue.
Joe
Oh cool. Mais comment dois-je mettre la formule? > _> J'ai essayé de le coller dans le blanc et il m'a demandé de créer un curseur, mais rien d'autre ne s'est produit.
Rɪᴋᴇʀ
@ EᴀsᴛᴇʀʟʏIʀᴋ: sur le côté gauche, où il est écrit "Input ..." Tout d'abord, pour initialiser n, entrez quelque chose comme n=297(cela vous donnera un curseur qui est bien configuré). Collez ensuite la formule dans la zone de saisie, qui doit maintenant se trouver sous le n. (Assurez-vous d'appuyer sur retour;) La formule doit correspondre au nterme de la séquence et elle doit changer lorsque vous déplacez le curseur.
Joe
2

Labyrinthe , 17 15 14 octets

Enregistré 3 octets en utilisant l'idée de Sok d'utiliser 1-(n%3)au lieu de ~(n%3-2).

1?:#/)}_3%-{*!

Le programme se termine avec une erreur (division par zéro), mais le message d'erreur est envoyé à STDERR.

Essayez-le en ligne!

Explication

Le programme est complètement linéaire, bien qu'un certain code soit exécuté en sens inverse à la fin.

1     Turn top of stack into 1.
?:    Read input as integer and duplicate.
#     Push stack depth (3).
/)    Divide and increment.
}     Move over to auxiliary stack.
_3%   Take other copy modulo 3.
-     Subtract from 1. This turns 0, 1, 2 into 1, 0, -1, respectively.
{*    Move other value back onto main stack and multiply.
!     Output as integer.

Le pointeur d'instruction atteint maintenant une impasse et se retourne, il commence donc à exécuter le code depuis la fin:

*     Multiply two (implicit) zeros.
{     Pull an (implicit) zero from the auxiliary to the main stack.
-     Subtract two (implicit) zeros from one another.
      Note that these were all effectively no-ops due to the stacks which are
      implicitly filled with zeros.
%     Attempt modulo, which terminates the program due to a division-by-zero error.
Martin Ender
la source
2

Erlang, 40 octets

F=fun(N)->trunc((N/3+1)*(1-N rem 3))end.

Malheureusement, Erlang n'a pas d'opérateur modulo '%' et 'rem' nécessite les espaces, même avant le 3.

fxk8y
la source
2

Hexagonie , 25 octets

?'+}@/)${':/3$~{3'.%(/'*!

Ou, au format non réduit:

    ? ' + }
   @ / ) $ {
  ' : / 3 $ ~
 { 3 ' . % ( /
  ' * ! . . .
   . . . . .
    . . . .

Essayez-le en ligne!

Ma première incursion dans Hexagony, donc je suis certain que je n'ai pas fait cela aussi efficacement que cela pourrait être fait ...

Calcule -(n%3 - 1)sur un bord de mémoire, n/3 + 1sur un bord adjacent, puis les multiplie ensemble.

Sok
la source
Wow, très intéressant de voir ça! :)
Adnan
2

R, 28 octets

-((n=scan())%%3-1)*(n%/%3+1)

On dirait que c'est une variation de la plupart des réponses ici. Basé sur zéro.

   n=scan()                  # get input from STDIN
  (        )%%3-1            # mod by 3 and shift down (0,1,2) -> (-1,0,1)
-(               )           # negate result (1,0,-1), this handles the alternating signs
                  *(n%/%3+1) # integer division of n by 3, add 1, multiply by previous

La bonne chose à ce sujet est qu'il gère plusieurs entrées

> -((n=scan())%%3-1)*(n%/%3+1)
1: 0 3 6 9 1 4 7 10 2 5 8 11
13: 
Read 12 items
 [1]  1  2  3  4  0  0  0  0 -1 -2 -3 -4
> 

À l'origine, je voulais faire ce qui suit, mais je ne pouvais pas couper les octets supplémentaires.

rbind(I<-1:(n=scan()),0,-I)[n]

Utilise rbindpour ajouter des 0 et des négatifs à une plage de 1 pour nensuite renvoyer le n'ème terme (un basé).

# for n = 5
rbind(                    )    # bind rows 
            n=scan()           # get input from STDIN and assign to n
      I<-1:(        )          # build range 1 to n and assign to I
                     ,0        # add a row of zeros (expanded automatically)
                       ,-I     # add a row of negatives
                           [n] # return the n'th term
MickyT
la source
2

Lot (Windows), 86 octets

Alternate.bat

SET /A r=%1%%3
SET /A d=(%1-r)/3+1
IF %r%==0 ECHO %d%
IF %r%==1 ECHO 0
IF %r%==2 ECHO -%d%

Ce programme est exécuté comme Alternate.bat nnest le numéro sur lequel vous souhaitez appeler la fonction.

Drew Christensen
la source
2

APL, 12 caractères

-×/1-0 3⊤6+⎕

0 3⊤appartient à APL divmod 3.

lstefano
la source
2

Java 7, 38 37 36 octets

Mon premier golf, sois doux

int a(int i){return(1+i/3)*(1-i%3);}

Essayez-le ici! (cas de test inclus)

Edit: j'ai mal compté et j'ai également joué un autre personnage en le remplaçant (-i%3+1)par (1-i%3).

Steven H.
la source
1
Bonjour et bienvenue chez PPCG! Vous pouvez supprimer l'espace après returnet utiliser un lambda Java 8.
NoOneIsHere
Je dois préciser qu'il s'agissait de Java 7. Je vais cependant supprimer cet espace. Merci!
Steven H.
1

MATLAB / Octave, 27 octets

@(n)ceil(n/3)*(mod(-n,3)-1)

Cela crée une fonction anonyme qui peut être appelée à l'aide de ans(n). Cette solution utilise une indexation basée sur 1.

Tous les cas de test

Suever
la source
1

Mathematica 26 octets

Avec 4 octets enregistrés grâce à Martin Ender.

⎡#/3⎤(-#~Mod~3-1)&

Utilise la même approche que Suever.

DavidC
la source
1

Octave, 23 octets

Sans aucun inconvénient ...

@(n)(-[-1:1]'*[1:n])(n)

Utilise la magie d'indexation basée sur 1.


Explication

Crée une fonction anonyme qui:

(-[-1:1]'*[1:n])(n)
  [-1:1]              % make a row vector [-1 0 1]
 -      '             % negate and take its transpose making a column vector
          [1:n]       % make a row vector [1..n], where n is the input
         *            % multiply with singleton expansion
               (n)    % use linear indexing to get the nth value

Après l'étape de multiplication, nous aurons une matrice 3xn comme ceci (pour n = 12):

 1    2    3    4    5    6    7    8    9   10   11   12
 0    0    0    0    0    0    0    0    0    0    0    0
-1   -2   -3   -4   -5   -6   -7   -8   -9  -10  -11  -12

Faire des ncolonnes est exagéré, mais c'est un nombre pratique qui est garanti d'être assez grand. L'indexation linéaire décompte chaque colonne de gauche à droite, de sorte que l'élément à indice linéaire 4serait2 .

Tous les cas de test sur ideone .

gobelet
la source
1

dc, 10

?2+3~1r-*p

Utilise l'indexation basée sur 1.

?              # Push input to stack
 2+            # Add 2
   3~          # divmod by 3
     1r-       # subtract remainder from 1
        *      # multiply by quotient
         p     # print
Traumatisme numérique
la source