J'apprends Ruby et j'ai écrit mon premier code non trivial pour résoudre ce problème.

Le défi consiste à générer les n premiers éléments de la séquence de Stöhr , S , qui est définie comme suit:

S [0] = 1

S [n] est le plus petit nombre qui ne peut pas être exprimé comme la somme de deux éléments précédents distincts dans la séquence.

Ainsi, la séquence commence par 1, 2, 4, 7 et 10. L'élément suivant est 13, car 11 (= 1 + 10) et 12 (= 2 + 10) sont des sommes d'éléments précédents, mais 13 ne l'est pas.

Je recherche le code le plus court. Le mien, dans Ruby, compte 108 caractères, mais j'attendrai peut-être de voir ce que les autres trouveront avant de le publier?

APL, 7

Dans APL, vous pouvez choisir si vous souhaitez travailler avec l'index 0 ou l'index 1. Pour ce faire, définissez la variable globale ⎕IO ← 0

Si nous choisissons de travailler dans l'index 0, nous avons:

+\3⌊1⌈⍳

Explication:

⍳    creates a sequence 0...n   (0 1 2 3 4 5)
1⌈   takes whichever is bigger, number in sequence or 1 (1 1 2 3 4 5)
3⌊   takes whichever is lower, number in sequence or 3 (1 1 2 3 3 3)
+\   partial sums for the sequence (1 2 4 7 10 13)

Essayez-le sur tryapl.org

Haskell - 11 21

Séquence infinie paresseuse

1:2:[4,7..]

Fonction qui retourne juste le nombre de membres fourni (soupir)

flip take$1:2:[4,7..]

Python 2, 37 35 octets

lambda n:[1,2][:n]+range(4,n*3-4,3)

Utilisation d'un motif ...

CJam, 14 octets

1l~{_p_3e<+}*;

Testez-le ici.

Commence à 1. Ensuite, S [n] = S [n-1] + min (S [n-1], 3) .

1l~{_p_3e<+}*;
1              "Push 1.";
 l~            "Read and evaluate input N.";
   {       }*  "Repeat this block N times.":
    _p         "Duplicate the last number and print it.";
      _3e<     "Duplicate it again, and take minimum with 3.";
          +    "Add to last number.";
             ; "Discard final number to prevent output.";

Cela se généralise facilement aux séquences h- Stöhr si l'on remplace 3 par 2 ^h -1 .

Brainfuck, 13 caractères

+.+.++.[+++.]

Ou 30 caractères si nous voulons le limiter à n sorties:

,->+.<[->+.<[->++.<[->+++.<]]]

Python, 136 octets

def f(n):
 if n<1:return[1]
 x=f(n-1);y=set(x)|{a+b for a in x for b in x if a!=b};return x+[min([a for a in range(1,max(y)+2)if{a}-y])]

Directement de la définition. Je ne sais pas combien je peux jouer au golf - c'est certainement beaucoup plus long que prévu.

J, 14 caractères

Cela code en dur la [1,2, 4+3*k (k=0..n-1) ]séquence et prend la première N.

   ({.1,2,4+3*i.) 10
1 2 4 7 10 13 16 19 22 25

.

J, 18 caractères

Celui-ci utilise une combinaison linéaire de [0,1,2,3...], [1,1,0,0...]et [0,1,1,1...]. Devrait être plus court mais ne semble pas pouvoir jouer au golf.

   ((3&*+<&2-2**)@i.) 10
1 2 4 7 10 13 16 19 22 25

Prélude , 32 20

Edit: ... avec deux fois plus de voix maintenant!

?(1-)
4 +3
2  ^
1 !^

Cela suppose que l' interpréteur Python avec NUMERIC_OUTPUT = True. Comme la soumission de Brainfuck, cette réponse suppose que l'entrée est donnée sous la forme d'un point de code. C'est en partie pour attirer plus d'attention sur cette méta discussion (et en partie, parce que j'aime Prelude). Donc, si vous voulez imprimer les 32 premiers chiffres, disons, vous devez mettre un espace sur STDIN. Bien sûr, cela signifie qu'il y a une limite supérieure aux entrées valides, mais cette réponse n'est pas gagnante de toute façon, donc je pense que dans les limites de Prelude, c'est très bien.

Explication

Dans Prelude, toutes les lignes sont exécutées en parallèle, cette ligne ayant sa propre pile, initialisée à une quantité infinie de zéros. Il n'y a qu'un seul pointeur d'instruction (pointant vers les colonnes), donc si vous entrez une boucle sur une voix, toutes les autres voix boucleront avec elle.

Dans ce qui suit, j'ai transposé le code, afin de pouvoir annoter des lignes au lieu de colonnes:

?421  Read a character into the first stack. Push 4, 2, 1 onto the other stacks, respectively.
      Generally, the fourth stack will hold the next number to be printed, the third stack the
      one after that, and the second stack the number two steps ahead.
(     Start a loop if the input wasn't 0.
1+ !  Push a 1 onto the first stack. Add the top elements in the second stack. On the first
      iteration this will be 0 and 4, so it does nothing. On all further iterations
      this will increment the last number by 3.
-3^^  Subtract one from the first stack. Push a 3 onto the second stack for the next iteration.
      Copy the last value from the second to the third, and the third to the fourth stack.
)     If the top of the first stack is not 0, jump back to the column after the (.

JavaScript (ES6) 92

En tant que fonction récursive basée sur la définition du problème

S=(n,v=1,s=[],r=0)=>[for(a of s)for(b of s)r+=(a-b&&a+b==v)]|r||(s.push(v),--n)?S(n,v+1,s):s

En utilisant le motif 1,2, 1 + 3 * k: 58

S=(n)=>(i=>{for(t=1;n>r.push(t+=i);i+=(i<3));})(0,r=[])||r

Note latérale: trouver la séquence h-Stöhr (vérifier la somme des hnombres au lieu de seulement 2). La Rfonction essaie toutes les sommes possibles d'un nombre donné d'éléments de liste.

S=(n,h=2,s=[],v=1,R=(t,v,l,i=0,r=t,w)=>{
  for(;r&&l&&v[i];i++)
    w=[...v],r=!R(t-w.splice(i,1),w,l-1)
  return!r;
})=>R(v,s,h)||(s.push(v),--n)?S(n,h,s,v+1):s

Ungolfed à peu près équivalent (et compatible ES5)

function S(n, v, s)
{
  var r=0,a,b
  v = v||1
  s = s||[]
  for(a of s)
    for(b of s)
    {
      if (a != b && a+b == v) 
        r++;
    }
  if (r == 0) 
  {
    s.push(v);
    --n;
  }
  if (n != 0)
     return S(n,v+1,s)
  else
     return s
}

Testez dans la console FireFox / FireBug. Fonction simple:

S(20)

[1, 2, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55]

Fonction avancée:

S(10,5)

[1, 2, 4, 8, 16, 32, 63, 94, 125, 156]

> <> (poisson) , 72 65 49 46 caractères

1n1-:?!;' 'o2n1-v
v1&no' ':<4&;!?:<
>-:?!;&3+^

L'entrée est fournie à l'interpréteur:

>fish.py stohr.fish -v 10
1 2 4 7 10 13 16 19 22 25

Mon premier> <> programme, suggestions appréciées.

> <>, 31 octets

4i1nao:?!;2nao1-:?!;$:nao3+$d0.

Lit dans un seul caractère, utilise son point de code (par exemple espace = 32) et imprime les chiffres un sur chaque ligne.

Perl6 22/30

Je vais voir si Perl6 peut déduire la séquence pour moi.

Pour ce faire, j'ai utilisé le REPL intégré à Perl6

$ perl6
> 1,2,4,7...*
Unable to deduce arithmetic or geometric sequence from 2,4,7 (or did you really mean '..'?)
> 1,2,4,7,10...*
1 2 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 ...

Hmm, je vois le motif que Perl a déduit. Après 4 pour obtenir la valeur suivante, vous ajoutez simplement 3.

1,2,4,*+3...*

Ce qui enregistre un caractère faisant le code pour obtenir une liste infinie des nombres dans la séquence de Stöhr de 13 caractères.

Ce code ne fait que quelque chose d'utile dans le REPL car il imprime l' essentiel du résultat pour nous. Pour le faire imprimer autrement, vous devrez explicitement dire à Perl d'imprimer les résultats.

$ perl6 -e 'say 1,2,4,*+3...*'

( * + 3est simplement un moyen d'obtenir une référence de code qui renvoie 3 ajoutés à son seul argument. D'autres façons de l'écrire seraient { $_ + 3 }, ou -> $i { $i + 3 }, ou { $^i + 3 }ou sub ($i){ $i + 3 })

Le moyen le plus court de créer quelque chose Callable pour générer les n premiers éléments est d'obtenir une tranche des éléments.

{(1,2,4,*+3...*)[^$_]} # 22

Dans un contexte vide qui générerait les premières $_valeurs, puis les jeter rapidement.

Dans tout autre contexte que vide, il crée un bloc de code anonyme (un sous-programme de base sans nom) qui prend un argument.

# store it in a scalar variable
my $sub = {(1,2,4,*+3...*)[^$_]};
say $sub.(5);
# 1 2 4 7 10

# use it immediately
say {(1,2,4,*+3...*)[^$_]}.(5);
# 1 2 4 7 10

# pretend it always had a name
my &Stöhr-first = {(1,2,4,*+3...*)[^$_]};
say Stöhr-first 5;

Si vous pensez vraiment qu'il doit avoir un nom pour être considéré comme valide pour ce défi, vous feriez probablement ceci:

sub s(\n){(1,2,4,*+3...*)[^n]} # 30

Bien que depuis ssoit également utilisé pour l'opérateur de substitution, pour appeler cela, les parens ne sont pas facultatifs. (Vous auriez pu lui donner un nom différent je suppose)

say s(5);
# 1 2 4 7 10

Je vois qu'il y a déjà une réponse java BEAUCOUP meilleure mais j'ai passé un moment là-dessus et je vais la poster. même si ça craint.

Caractère Java 313 (+4 pour l'adapter à l'écran)

import java.util.*;public class S{public static void main(String[] a){
Set<Integer> S=new HashSet<Integer>();S.add(1);int i=1,k=0;
while(S.size()<=new Integer(a[0])){if(S.contains(i)){}else{k=0;for(int j:S){
for(int l:S){if(l!=j){if((j+l)==i)k=1;}}}if(k==0)S.add(i);}i++;}for(int x:S)
{System.out.println(x);}}}

toujours reconnaissant d'avoir des conseils ou des conseils sur la façon d'améliorer

T-SQL 204

Suppose que l'entrée se trouve dans une variable appelée @N. Je peux faire une procédure si vous le souhaitez, mais il n'y a vraiment pas de bon moyen d'obtenir STD_IN en T-SQL.

Aussi, oui pour le bonus moral!

DECLARE @Q INT=0,@B INT=2
DECLARE @ TABLE(A INT)WHILE @N>0
BEGIN
SET @N-=1
WHILE @B>1
BEGIN
SET @Q+=1
SELECT @B=COUNT(*)FROM @ C,@ B WHERE C.A+B.A=@Q
END
INSERT INTO @ VALUES(@Q)SET @B=2
END
SELECT*FROM @

Mathematica, 27 octets

Hmmm, toujours pas de réponse Mathematica? En voici deux:

NestList[#+3~Min~#&,1,#-1]&
Array[i=1/2;i+=3~Min~i&,#]&

les deux définissent une fonction pure sans nom qui reçoit un entier et renvoie une liste d'entiers. Ceci est basé sur la même relation de récurrence que ma soumission de CJam. Notez que le Arraycode basé sur commence à partir 1/2, car la relation de récurrence est toujours appliquée avant que la valeur ne soit renvoyée.

Java, 46

n->IntStream.iterate(2,x->x==2?1:x+3).limit(n)

Python - même pas proche (139)

Agissant sous l'hypothèse que cela n'était pas facilement calculable comme d'autres l'ont fait, la solution la plus courte que j'ai trouvée est ci-dessous:

from itertools import combinations as C
x,i,n=[],1,input()
while len(x)<=n:
 if i not in [sum(y) for y in C(x,2)]:x.append(i)
 i+=1
print n

Clojure - 130 118

(defn s[n](last(take n(iterate #(if(<(count %)3)(conj %(+ (apply + %)1))(conj %(+(last %)(second %)(first %))))[1]))))

Version sans golf:

(defn stohr [n]
  (last
    (take n
      (iterate #(if (< (count %) 3)
                   (conj % (+ (apply + %) 1))
                   (conj % (+ (last %) (second %) (first %)))) [1]))))

Partagez et profitez.

Rubis - 108 88

q=->n{*k=1;(m=k[-1];k<<([*m+1..2*m]-k.combination(2).map{|i,j|i+j})[0])while k.size<n;k}

Cela utilise la définition de la séquence.

Version plus lisible:

q=->n{
    *k=1
    (
        m = k[-1]
        k << ([*m+1..2*m] - k.combination(2).map{|i,j|i+j})[0]
    ) while k.size < n
    k
}

imprimer q [10]

[1, 2, 4, 7, 10, 13, 16, 19, 22, 25]

STATA 51

di 1 2 _r(a) 
loc b=3*$a-2
forv x=4(3)`b'{
di `x'
}

TI-BASIC, 41 27 30 octets

Pour votre calculatrice

Input N:For(I,1,N:I:If I>2:(I-2)3+1:Disp Ans:End

GML , 67 octets

n=argument0;for(i=1;i<=n;i++){t=i;if i>2t=(i-2)*3+1show_message(t)}