Numéros de saut

14

TÂCHE

affiche les entiers n, où 12 <= n <= 123456789et toutes les paires de chiffres consécutifs dans n ont la même différence positive entre eux (par exemple 2468 mais pas 2469).

PAS D'ENTRÉE.

Production:

12
13
14
15
16
17
18
19
23
24
25
26
27
28
29
34
35
36
37
38
39
45
46
47
48
49
56
57
58
59
67
68
69
78
79
89
123
135
147
159
234
246
258
345
357
369
456
468
567
579
678
789
1234
1357
2345
2468
3456
3579
4567
5678
6789
12345
13579
23456
34567
45678
56789
123456
234567
345678
456789
1234567
2345678
3456789
12345678
23456789
123456789

Règles

  1. Des échappatoires standard s'appliquent.
  2. pas d'entrée

le code le plus court gagne.

Crédits anarchy golf

code-golf  number  sequence  kolmogorov-complexity 
— 0x45
source
8
Ce problème vient du golf d'anarchie . Vous devriez lui donner du crédit (même si c'est vous qui l'avez soumis)
— xnor
5
Doivent-ils être imprimés dans l'ordre?
— H.PWiz
11
J'ai soumis ce problème sur anagol :)
— Lynn
2
Pourquoi chaque entier 0≤n <100 n'est-il pas sur cette liste?
— DonielF
3
@DonielF Parce que l'entier doit être supérieur ou égal à 12, et parce que les différences directes doivent être positives.
— Dennis

Réponses:

11

Gelée , 12 11 octets

9œcḊẎIE$ÐfY

Essayez-le en ligne!

Comment ça fonctionne

9œcḊẎIE$ÐfY  Main link. No arguments.

9            Set the argument and return value to 9.
   Ḋ         Dequeue; yield [2, ..., 9].
 œc          Take all k-combinations of [1, ..., 9], for each k in [2, ..., 9].
    Ẏ        Concatenate the arrays of k-combinations.
        Ðf   Filter the result by the link to the left.
     IE$         Compute the increments (I) of the combination / digit list and
                 tests if all are equal (E).
          Y  Join the results, separating by linefeeds.
— Dennis
source
ìà Find fastest route between two points using Dykstra's Algorithm
— Neil
7

Python 2 , 81 octets

k=71
exec"k+=1;r=range(k/8%9+1,10,k%8+1)\nif r[k/72:]:print`r`[1:k/24+2:3]\n"*576

Essayez-le en ligne!

Ma solution de l'anarchy golf. L'idée est d'itérer sur tous les triplets possibles de longueur, de valeur de départ et de pas, ce qui donne des sorties triées. La triple est codée comme une valeur rde 72à 647, et les composants sont extraits en tant que k/72, k/8%9etk%8 . Un démarrage ksuffisamment élevé évite la sortie de nombres à un chiffre.

xsot a économisé deux octets en remplaçant lerange par une chaîne de chiffres codée en dur '123456789'.

Cela a été écrit sous la contrainte d'une limite d'exécution de deux secondes. Une stratégie plus lente qui filtre les nombres plutôt que d'en générer peut être plus courte.

— xnor
source
1
Fait amusant: ce problème est en fait «conçu pour» la limite d'exécution du golf anarchique, c'est pourquoi je ne l'ai pas soumis à PPCG. Je voulais disqualifier les soumissions en boucle de 1à 123456789, forçant plutôt les réponses à trouver un moyen intelligent de générer les bons nombres dans le bon ordre (trié).
— Lynn
6

C, 166 152 octets

p,l,d,i=11;main(){for(char s[10];i<=1e9;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(!p)p=d;if(p^d|d<1)break;p=d;}if(!l)puts(s);}}

6 octets enregistrés grâce à @KevinCruijssen!

8 octets économisés grâce à @JonathanFrech!

Essayez-le en ligne

La version entièrement formatée du code ci-dessus peut être vue ci-dessous.

#include <string.h>
#include <stdio.h>

int main( void )
{
int prev_diff, diff, len;
int num = 11;
char str[10];

while(num<123456789)
    {
    prev_diff = 0;
    sprintf(str,"%d",++num);
    len = strlen(str)-1;
    for( ; len > 0; len-- )
        {
        diff = str[len] - str[len-1];
        if( prev_diff == 0 )
            {
            prev_diff = diff;
            }
        if( prev_diff != diff || diff < 1 )
            {
            break;
            }
        prev_diff = diff;
        }
    if ( len == 0 )
        {
        puts(str);
        }
    }
}
— Jacobinski
source
À moins que je manque quelque chose, ne devrait-il pas plutôt while(i<123456789)être en while(i<=123456789)fonction de la gamme de défis? En outre, vous pouvez p,l,d,i=11;main(){for(char s[10];i<=123456789;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(p<1)p=d;if(p^d|d<1)break;p=d;}if(l<1)puts(s);}}
— jouer au
@KevinCruijssen Je serais d'accord, bien que l'on puisse très probablement continuer à utiliser la comparaison à un octet en choisissant une valeur plus élevée; i<1e9.
— Jonathan Frech
@KevinCruijssen Aussi, si je ne me trompe pas, l<1peut être joué au golf !l, car ln'atteint jamais une valeur négative.
— Jonathan Frech
@JonathanFrech Bon point sur le i<1e9. Et !lquand ça sonne ltoujours >=0raisonnable pour CI suppose (je n'ai jamais programmé en C moi-même).
— Kevin Cruijssen
@KevinCruijssen "i" est incrémenté dans sprintf (), nous permettant d'atteindre ce qui nous permet d'entrer dans la boucle quand i == 123456788, et de le laisser avec 123456789. J'ajouterai ces multi-usages pour les boucles et (l == 0 ) -> (l <1) optimisations, merci :)
— Jacobinski
5

Gelée , 14 , 13 octets

DIµEȧ>0Ȧ
Ç77#

Essayez-le en ligne!

Un octet sauvé grâce à @MrXcoder!

C'est extrêmement inefficace, donc ça va s'arrêter sur TIO, mais si jamais ça se termine, ça produira la sortie correcte. Vous pouvez l'essayer avec de plus petits nombres ici: Essayez-le en ligne!

Explication:

            # Helper link:
            #
D           # The Digits of 'n'
 I          # The increments (deltas, differences) between digits
  µ         # Give that array as an argument to the rest of this link:
   E        # Are all elements equal?
    ȧ       #   AND
     >0     # Are all elements greater then 0?
       Ȧ    # And is there at least one element?
            # (in the differences, so that numbers < 10 are false)
            #
            # Main link:
            #
 77#        # Return the first 77 'n's for which
Ç           #   The helper link is truthy
— James
source
1
Pouah. Battez-moi. +1
— caird coinheringaahing
Vous n'avez pas besoin du $à la fin de votre lien d'assistance.
— M. Xcoder
Une façon plus claire de le faire estDIµ>0ȦȧE¶Ç77#
— Erik the Outgolfer
4

05AB1E , 23 octets

•7=›ζ•FNS¥DËs0›PN11›&&–

Essayez-le en ligne!

Remplacez-le •7=›ζ•par 7000 pour le terminer sur TIO, ou appuyez simplement sur le bouton "Terminer" avant qu'il n'expire, ce qui entraîne l'impression des chiffres jusqu'à ce point.

— Urne de poulpe magique
source
Essayez d'utiliser ceci:žh
— Okx
@Okx Je ne pense pas que cela fonctionnerait, ce n'est pas seulement une sous-chaîne de '0123456789', 1357par exemple, c'est aussi un nombre valide que vous devez sortir.
— Erik the Outgolfer
@EriktheOutgolfer Je voulais dire remplacer•7=›ζ•
— Okx
@Okx, c'est ce que j'avais à l'origine, mais cela provoque des trucs bizarres (?). Je ne sais pas pourquoi, donc je me suis retrouvé avec cela, qui a fonctionné de manière cohérente.
— Urne de poulpe magique du
@MagicOctopusUrn Pourquoi n'essayez-vous pas de supprimer le 0 au début?
— Okx
4

Mathematica, 79 octets

Select[Range@123456789,Min[s=Union@Differences@IntegerDigits@#]>0&&Tr[1^s]==1&]

Essayez-le en ligne!avec un nombre inférieur car il est très lent

voici une autre approche qui construit tous les nombres en 1sec

Mathematica, 123 octets

Union[FromDigits/@(F=Flatten)[Table[Partition[#,i,1],{i,2,9}]&/@Select[F[Table[Range[j,9,k],{j,9},{k,9}],1],Tr[1^#]>1&],2]]


Essayez-le en ligne! tous les nombres en une seconde

— J42161217
source
4

Husk , 14 13 octets

ÖifȯεuẊ≠Ṗ…"19

Imprime les numéros séparés par des sauts de ligne dans STDOUT. Essayez-le en ligne!

-1 octet en raison de l'inspiration de H.PWiz.

Explication

ÖifȯεuẊ≠Ṗ…"19
         …"19  The string "19" rangified: "123456789"
        Ṗ      Powerset: ["","1","2","12","3",...,"123456789"]
  fȯ           Filter by function: (input is sublist, say "2469")
      Ẋ≠        Consecutive codepoint differences: [2,2,3]
     u          Remove duplicates: [2,3]
    ε           Is it a one-element list? No, so "2469" is dropped.
Öi             Sort the result by integer value, implicitly print separated by newlines.
— Zgarb
source
3

APL (Dyalog) , 37 28 octets

⍪x/⍨{1=≢∪2-/⍎¨⍕⍵}¨x←11+⍳1E9

Essayez-le en ligne! (avec une plage plus courte, en raison de la temporisation)

Comment?

x←11+⍳123456789- 11, 12... 1e9enx

¨ - pour chaque

    ⍎¨⍕⍵ - divisez en chiffres

    2-/ - obtenir la liste des différences

    ∪ - obtenez des éléments uniques

    1=≢ - longueur == 1?

x/⍨ - utilisez-le comme masque sur la gamme créée

⍪ - et colonne

— Uriel
source
3

Lot, 210 200 octets

Aucune optimisation, donc très lent - prend environ 25 secondes jusqu'à 12345, donc pour la sortie complète, vous devrez attendre environ 3 jours.

@set z=@set/a
%z%c=12
:a
@echo %c%
:c
%z%c+=1&if %c%==123456790 exit/b
%z%n=c
%z%d=n%%10-n/10%%10
@if %d% leq 0 goto c
:d
%z%n=n/10
@if %n% leq 9 goto a
%z%e=n%%10-n/10%%10
@if %e%==%d% goto d
@goto c
— schnaader
source
3

Java 8, 169 168 145 octets

v->{byte[]a;for(int i=9,d,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),d=0,l=a.length;--l>0&&d*(d^(d=a[l]-a[l-1]))<1&d>0;);}

Port de @Jacobinski C réponse (après l'avoir un peu joué au golf ).
-23 octets grâce à @Nevay .

Explication:

Essayez-le ici. (C'est un peu trop lent vers la fin, donc n'imprime pas le numéro final sur TIO. Il imprime le numéro final localement en environ 20 secondes, cependant.)

v->{                         // Method with empty unused parameter and no return-type
  byte[]a;                   //  Byte-array
  for(int i=9,               //  Index integer, starting at 9
          d,                 //  Difference-integer
          l;                 //  Length integer
      ++i<1e9;               //  Loop (1) from 10 to 1,000,000,000 (exclusive)
      System.out.print(      //    After every iteration: print:
        l<1?                 //     If `l` is 0:
         i+"\n"              //      The current integer + a new-line
        :                    //     Else:
         ""))                //      Nothing
    for(a=(i+"").getBytes(), //   Convert the current item as String to a byte-array
        d=0,                 //   Reset the previous integer to 0
        l=a.length;          //   Set `l` to the length of the byte-array
        --l>0                //   Inner loop (2) from `l-1` down to 0 (exclusive)
        &&d*(d^(d=a[l]-a[l-1]))<1
                             //    As long as the previous difference is either 0
                             //    or the current diff is not equal to the previous diff
        &d>0;                //    and the current diff is larger than 0
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
}                            // End of method
— Kevin Cruijssen
source
1
145 octets:v->{byte[]a;for(int i=9,p,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),p=0,l=a.length;--l>0&&p*(p^(p=a[l]-a[l-1]))<1&p>0;);}
— Nevay
@Nevay, je savais qu'il devrait pouvoir le supprimer d'une breakmanière ou d'une autre et l'ajouter à la vérification de la boucle, mais je ne l'aurais pas trouvé moi-même. ;) Merci!
— Kevin Cruijssen
2

05AB1E , 14 octets

TžhŸʒS¥D0›PsË&

Essayez-le en ligne!

— Okx
source
C'est ce que j'avais à l'origine, sauf que j'avais 12žhŸʒS¥D0›PsË&, je ne peux pas le faire fonctionner localement. Pouvez-vous obtenir que cela s'exécute réellement?
— Urne de poulpe magique
@MagicOctopusUrn Si j'essaie de remplacer les numéros avant Ÿ, ça marche très bien
— Okx
J'ai fait exécuter mon autre localement sans remplacer les numéros, mais je ne peux toujours pas. Idk pourquoi, je veux juste vraiment savoir ce qui est si différent.
— Urne de poulpe magique
2

Python 2 , 76 75 octets

n=9
while n<2e8:
 n+=1
 if`n`in`range(n%10,0,~n%100%11-11)`[-2::-3]:print n

Prend environ 3 minutes localement.

Essayez-le en ligne! (modifié pour imprimer tous les numéros sauf le dernier)

— Dennis
source
2

JavaScript (Firefox 30-57), 105 octets

document.write(`<pre>`+(

_=>[for(x of s=`123456789`)for(y of s)for(z of s)if(x*z<10-y)s.replace(/./g,c=>c<y|(c-y)%z|c-y>x*z?``:c)]

)().join`\n`+`</pre>`);
Développer l'extrait

Boucles sur des longueurs de 2 à 10 (x est l'index du dernier caractère et donc 1 de moins que la longueur), en commençant les chiffres de 1 à 9 et les pas de 1 à 9, puis les filtres sur le dernier chiffre étant inférieur à 10 et si génère donc le résultat en filtrant les chiffres de la chaîne de chiffres.

— Neil
source
"Exécuter l'extrait de code" conduit à une erreur:Uncaught SyntaxError: Unexpected token for
— schnaader
2
@schnaader L'utilisez-vous dans Firefox 30+? Cette réponse utilise la syntaxe de compréhension de tableau non standard que seul Firefox prend en charge.
— Birjolaxew
Ah, je n'ai pas vu la remarque, désolé pour ça.
— Fonctionnait
1

JavaScript (ES6), 121 octets

Pas aussi court que la réponse de Neil , mais je pensais que cela valait toujours la peine d'être publié.

Fonctionne en créant un ensemble de pouvoirs '123456789'où toutes les entrées non correspondantes sont tronquées et préfixées 0, en triant les résultats dans l'ordre numérique et en ne gardant que les 77 pertinentes.

_=>[...'123456789'].reduce((a,x)=>[...a,...a.map(y=>y[1]-y[0]+(y.slice(-1)-x)?'0':y+x)],['']).sort((a,b)=>a-b).slice(-77)

Démo

Afficher l'extrait de code

— Arnauld
source
1

C (gcc) , 106 octets

main(i,j,k,l){for(i=1;i<9;i++)for(j=8;j;j--)for(k=0;k<j/i;puts(""))for(l=0*k++;l<=i;)putchar(57-j+k*l++);}

Essayez-le en ligne!

La version non golfée (raffinée):

int main() {
  int length, start_with, max_step, step, nth;
  for (length = 2; length <= 9; length++) {
    for (start_with = 1; start_with < 9; start_with++) {
      max_step = (9 - start_with) / (length - 1);
      for (step = 1; step <= max_step; step++) {
        for (nth = 0; nth < length; nth++) {
          putchar('0' + start_with + step * nth);
        }
        puts("");
      }
    }
  }
  return 0;
}
— tsh
source
1

JavaScript (ES6), 109 104 octets

Fonctionne en générant tous les nombres possibles: boucle à travers chaque incrément de 8 à 1 (variable i), boucle à travers chaque chiffre de départ de 8 à 1 (variable j), boucle à travers chaque chiffre entre jet 10-i(variable k) et génère une chaîne ten ajoutant kau courant t. À chaque étape, test ajouté au tableau de sortie.

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

Essayez-le en ligne!

f=

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

;
console.log(f().join("\n"))
Développer l'extrait

— Birjolaxew
source
0

JavaScript (ES6), 145 octets

Une approche directe avec peu de magie.

Array(123456790).fill().map((x,i)=>(''+i).split('')).map((a,i,d) => {d=a[1]-a[0];d>0&a.every((n,j)=>j<1||n-a[j-1]==d)?console.log(a.join('')):0})
Développer l'extrait

L'exécution de l'extrait consommera beaucoup de mémoire ...

— sshow
source
0

PHP, 85 84 octets

for(;++$d<9||++$a<9*$d=1;sort($r))for($x=$y=$a+1;10>$y+=$d;)$r[]=$x.=$y;print_r($r);

essayez-le en ligne .

le tri coûte 17 octets. Cette version imprime les résultats classés différemment:

while(++$d<9||++$a<9*$d=1)for($x=$y=$a+1;10>$y+=$d;)echo"
",$x.=$y;
— Titus
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.