Moitié Moitié Moitié


33

Considérons la séquence numérique suivante:

0,12,14,34,18,38,58,78,116,316,516,716,916,1116,1316,1516,132,332,532,

Il énumère toutes les fractions binaires dans l'intervalle unitaire .[0,1)

(Pour faciliter ce défi, le premier élément est optionnel: vous pouvez le sauter et considérer que la séquence commence par 1/2.)

Tâche

Ecrivez un programme (programme complet ou une fonction) qui ...

Choisissez l'un de ces comportements:

  • Entrée n, sortie nième élément de la séquence (indexé 0 ou indexé 1);
  • Entrer n, sortir n premiers éléments de la séquence;
  • N'entrez rien, indiquez la suite de nombres infinis que vous pouvez prendre l'un après l'autre;

Règle

  • Votre programme doit au moins prendre en charge les 1000 premiers éléments.
  • Vous pouvez choisir de produire des décimales ou des fractions (paire intégrée, paire entière, chaînes) à votre guise;
    • Les entrées / sorties sous forme de chiffres binaires ne sont pas autorisées dans cette question;
  • C'est le , les codes les plus courts gagnent;
  • Lacunes standard interdites.

Testcases

input output
1     1/2     0.5
2     1/4     0.25
3     3/4     0.75
4     1/8     0.125
10    5/16    0.3125
100   73/128  0.5703125
511   511/512 0.998046875
512   1/1024  0.0009765625

Ces exemples sont basés sur une séquence indexée par 0, le 0 initial étant inclus. Vous auriez besoin d'ajuster l'entrée pour adapter votre solution.

Lire la suite

  • OEIS A006257
    • Problème de Josèphe: . (Anciennement M2216)a2n=2unen-1,une2n+1=2unen+1
    • 0, 1, 1, 3, 1, 3, 5, 7, 1, 3, 5, 7, 9, 11, 13, 15, 1, 3, 5, ...
  • OEIS A062383
    • une0=1 : pour , ou .n>0unen=2log2n+1unen=2unen2
    • 1, 2, 4, 4, 8, 8, 8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 32, 32, 32, ...
  • A006257 (n) / A062383 (n) = (0, 0,1, 0,01, 0,11, 0,001, ...) énumère toutes les fractions binaires de l'intervalle unitaire [0, 1). - Fredrik Johansson, 14 août 2006


4
" Ne rien entrer, sortir la séquence des nombres infinis un par un " Faut-il que ce soit un par un, ou sommes-nous également autorisés à sortir une liste infinie (possible dans Haskell, Elixir, 05AB1E, etc.)?
Kevin Cruijssen le

Puis-je sortir une liste de chaînes? par exemple"1/2" "1/4" "1/8"...
Barranka

@KevinCruijssen La liste infinie est correcte tant que vous pouvez taken éléments plus tard.
tsh

@Barranka Je pense que c'est acceptable. Ce n’est pas différent d’imprimer des fractions sur la sortie standard.
tsh

Lorsque vous dites que l' entrée / la sortie sous forme de nombres binaires n'est pas autorisée , vous voulez dire que nous ne pouvons pas écrire une fonction qui retourne une paire si ints, ni doubledans un langage / une implémentation doubleutilisant le format binaire64 IEEE ? J'espère que vous ne voulez pas dire qu'il faut analyser une chaîne ASCII si on veut prendre une entrée entière? Les types entiers normaux sont binaires dans des langages tels que C. Ou voulez-vous dire que l'entrée / sortie ne peut pas être un tableau ou une chaîne d'entier ou des zéros / uns ASCII?
Peter Cordes

Réponses:


22

Haskell , 25 octets

pred.until(<2)(/2).(+0.5)

Essayez-le en ligne!

Sorties décimales, index unique sans le terme zéro initial.

Ajoute 0,5 à l'entrée, puis divise par deux jusqu'à ce que le résultat soit inférieur à 2, puis soustrait 1. L'utilisation d'une expression sans points permet de gagner 1 octet sur

f n=until(<2)(/2)(n+0.5)-1

11

Java 10, 68 64 octets

Essayez d'abord le code golf!

Option 1: trouver le n- ième élément (indexé 1)

-4 octets grâce à @ Kevin Cruijssen

n->{int x=0;for(;n>>++x!=1;);return((~(1<<x)&n)*2.+1)/(1<<x+1);}

Il s'agit d'une méthode anonyme qui trouve le n- ième terme en supprimant le bit le plus significatif de n , en le doublant et en en ajoutant un, puis en le divisant par la puissance immédiatement supérieure de 2.

Essayez-le en ligne!

Procédure pas à pas du code:

n->{                      // builds anonymous function with input n
int x=0;                  // stores floor of log(n) (base 2) for most significant digit
for(;n>>++x!=1;);         // calculates floor of log(n) by counting right shifts until 1
return((~(1<<x)&n)        // removes most significant digit of n
*2.+1)                     // multiplies 2 and adds 1 to get the odd numerator
/(1<<x+1);}               // divides by the next highest power of 2 and returns`

Va modifier s'il est nécessaire d'imprimer la valeur finale au lieu de la renvoyer.


Bienvenue sur PPCG, ravi de vous accueillir parmi nous :)
Shaggy, le

Bonjour, bienvenue sur PPCG! Super première réponse, +1 de moi. Actuellement, c'est le même nombre d'octets que ma réponse Java, mais vous pouvez quand même jouer au golf certaines parties de votre réponse pour la rendre plus courte que la mienne: La {}boucle après la boucle peut être un ;remplacement; vous pouvez supprimer l'espace après le return; 2.0peut être 2.; Et changer la n>>x!=1;x++, 1<<xet 1<<x+1à n>>x++!=1;, 1<<x-1, 1<<xrespectivement enregistre également un octet. Essayez-le en ligne: 64 octets . Profitez de votre séjour!
Kevin Cruijssen

Oh, et si vous ne l'avez pas encore vu: Astuces pour jouer au golf en Java et Astuces pour jouer au golf dans <toutes les langues> sont très intéressantes à lire. :)
Kevin Cruijssen le

Voir ma réponse de 30 octets , basée à l'origine sur la vôtre mais golfée et golfée.
Olivier Grégoire

9

MathGolf , 5 4 octets

╫\╨]

Essayez-le en ligne!

A quoi ça ressemblerait si l'opérateur travaillait correctement

╫\)╨]   (")" adds 1 to TOS, making rounding behave as expected)

Essayez-le en ligne!

Explication

╫     Left-rotate all bits in input
 \    Swap top two elements on stack, pushing the input to the top
  ╨   Round up to nearest power of 2
   ]  Wrap in array (just for pretty printing)

Je me suis inspiré de cette question pour résoudre le problème, ma "propre" solution se situant autour de 10 à 12 octets, je pense.

J'avais eu l'intention de renvoyer le numéro à la puissance 2 la plus proche, s'il s'agissait d'un nombre de deux, mais en raison d'une erreur, il arrondit à la puissance suivante de deux (par exemple 4 -> 8 au lieu de 4 -> 4 ). Cela devra être corrigé plus tard, mais maintenant cela me sauve un octet.


2
Je ne connais pas MathGolf, mais si cela ]ne sert à rien de formater la sortie, je dirais que vous n’avez pas besoin de l’inclure dans votre nombre d’octets.
Shaggy

2
J'étais incertain à ce sujet. Comme la pile est imprimée en sortie sous forme de chaîne jointe, elle génère une pile avec les nombres 1 et 2 sous la forme 12. Si cela compte toujours, je supprime un octet
maxb

Je pense que vous devriez le laisser dedans. Il enregistre parfois un octet pour sortir la pile en une chaîne, parfois cela vous coûtera un octet.
H.PWiz

@ H.PWiz, c'était ma pensée initiale, car il semble juste d'utiliser les points forts de votre langage. Certaines langues n'impriment que le haut de la pile à la fin, d'autres sous forme de liste. En général, la différence est de 1 octet, mais cela fait partie du défi.
maxb

8

Java 10, 89 85 70 69 68 octets

v->{for(float j,t=2;;t*=2)for(j=1;j<t;j+=2)System.out.println(j/t);}

Port de la réponse 05AB1E de @Emigma , affiche également les nombres décimaux indéfiniment.
-15 octets grâce à @Arnauld .

Essayez-le en ligne.

Explication:

v->{                      // Method with empty unused parameter and no return-type
  for(float j,t=2;;       //  Loop `t` from 2 upwards indefinitely,
                   t*=2)  //  doubling `t` after every iteration
    for(j=1;j<t;          //   Inner loop `j` in the range [1, `t`),
                j+=2)     //   in steps of 2 (so only the odd numbers)
      System.out.println( //    Print with trailing new-line:
        j/t);}            //     `j` divided by `t`

1
Combien de fois puis-je dire que je compte la moitié de vos octets? Eh bien, je pense que c'est la première fois ;-)
Olivier Grégoire

@ OlivierGrégoire Dang, voilà une réponse impressionnante en Java. :) J'ai vu votre version de 37 octets comme un commentaire sur la réponse de TCFP, mais vous avez même retiré plus d'octets. Cela semble extrêmement simple maintenant dans votre version à 30 octets, mais la façon dont vous l'avez jouée depuis la version initiale reste ingénieuse. Bien joué!
Kevin Cruijssen le



7

Java (JDK 10) , 30 octets

n->(n+.5)/n.highestOneBit(n)-1

Essayez-le en ligne!

Renvoie le n ième élément de la séquence.

Cette réponse est à l'origine une succession de parcours de la réponse Java de TCFP . À la fin, les golfs ne ressemblaient plus à la réponse initiale (bien que les calculs fussent les mêmes), alors j'ai décidé de les publier séparément, au lieu de simplement commenter la réponse du PFCT. Donc, si vous aimez cette réponse, augmentez la réponse de TCFP également! ;-)

Les golfs intermédiaires étaient:

n->{int x=0;for(;n>>++x!=1;);return((~(1<<x)&n)*2.+1)/(1<<x+1);} // 64 bytes (TCFP's answer when I started golfing)
n->{int x=0;for(;n>>++x!=1;);x=1<<x;return((~x&n)*2.+1)/x/2;}    // 61 bytes
n->{int x=n.highestOneBit(n);return((~x&n)*2.+1)/x/2;}           // 54 bytes
n->{int x=n.highestOneBit(n);return((~x&n)+.5)/x;}               // 50 bytes
n->((n&~(n=n.highestOneBit(n)))+.5)/n                            // 37 bytes
n->(n-(n=n.highestOneBit(n))+.5)/n                               // 34 bytes
n->(n+.5)/n.highestOneBit(n)-1                                   // 30 bytes, current score

Et j'étais assis ici, pensant que ma réponse était aussi courte que possible, tu viens et tu la coupes par plus de la moitié! Un truc incroyable, mérite certainement un +1 de ma part.
TCFP

@TCFP C'était un processus itératif sur plusieurs heures. En fait, j'ai posté chaque golf intermédiaire en tant que commentaire à votre réponse, mais je les ai supprimés car j'ai trouvé de meilleurs golfs. Merci pour les éloges ;-)
Olivier Grégoire

6

05AB1E , 11 8 octets

3 octets sauvés grâce à Kevin Cruijssen .

∞oDÅÉs/˜

Essayez-le en ligne!

Explication

∞         # start an infinite list [1...
 o        # calculate 2**N
  D       # duplicate
   ÅÉ     # get a list of odd numbers up to 2**N
     s/   # divide each by 2**N
       ˜  # flatten

1
-1 octet en utilisant (liste infinie commençant à 1):∞oεDÅÉs/}˜
Kevin Cruijssen le

@ KevinCruijssen: Cool! C'est une commande que je n'avais jamais vue auparavant. Merci :)
Emigna

1
Ah, et une bonne façon de sauver deux octets de plus en raison de la mappage implicite ..
N'y

1
: O comment est-ce possible. Vous avez condensé la question de ~ 2 pages en 8 octets.
Cullub

Je pensais utiliser les nombres premiers et une liste de [1,2,4,4,8,8,8,8,16,16,...,2**n]préfixes indexés suivis d'un /… mais cela ne fonctionnait pas si bien. Bien, mais pas 8-bytesbien. Quelque chose comme 9LoDÅP)ζ.
Urne Magique Octopus


5

PowerShell , 40 octets

for($i=2;;$i*=2){1..$i|?{$_%2}|%{$_/$i}}

Essayez-le en ligne!

Affiche la séquence infinie sous forme de valeurs décimales. Compte tenu des limitations linguistiques, rencontrera éventuellement des problèmes de précision, mais gère facilement les 1000 premières entrées.

Commence par régler $i=2, puis entre dans une forboucle. À chaque itération, nous construisons une plage 1..$iet extrayons les valeurs impaires avec |?{$_%2}. Ceux-ci sont introduits dans leur propre boucle interne, où nous divisons chacun pour obtenir la décimale |%{$_/$i}. Ceux-ci sont laissés sur le pipeline et sortent lorsque le pipeline est vidé après chaque foritération. Chaque itération nous incrémenter simplement $ipar $i*=2pour obtenir le prochain go-round.


5

Haskell, 35 32 octets

Edit: -3 octets grâce à @ Delfad0r.

[(y,2^x)|x<-[1..],y<-[1,3..2^x]]

C'est une liste infinie de paires d'entiers.

Essayez-le en ligne!


5

Haskell , 40 octets

s=(1,2):[(i*2+u,j*2)|(i,j)<-s,u<-[-1,1]]

Essayez-le en ligne!

Séquence infinie sous forme de paires d'entiers (à partir de (1,2)).

Un peu plus long que la réponse de @ nimi , mais l'approche est complètement différente, j'ai donc décidé de le poster quand même.

Cette solution est basée sur l'observation suivante.

{12,14,34,18,38,58,78,116,316,}

  • jej{2je-12j,2je+12j}
    {{14,34},{18,38},{58,78},{116,316},}
  • {14,34,18,38,58,78,116,316,}
  • 12
    {12,14,34,18,38,58,78,116,316,}

Remarquez comment vous revenez à la séquence avec laquelle vous avez commencé!

La solution exploite ce fait (avec la paresse de Haskell) pour calculer la séquence s.


4

Python 2 - 68 66 octets

-2 octets grâce à Kevin

from math import*
def g(n):a=2**floor(log(n,2));print(n-a)*2+1,2*a

Essayez-le en ligne!


Vous pouvez jouer au golf 1 octet en changeant return 2*(n-a)pour return(n-a)*2. Et vous pouvez enregistrer un octet supplémentaire en utilisant Python 2 au lieu de 3, donc vous returnpouvez le faire print(avec des parenthèses).
Kevin Cruijssen le

2
@KevinCruijssen Pour quelqu'un qui n'utilise pas Python, vous êtes certainement un meilleur programmeur Python que moi.
Don Thousand

Héhé. : D Des choses simples comme celle-ci viennent avec l'expérience, je suppose. Je suis sur ce site depuis environ deux ans maintenant, je pense (EDIT: depuis avril 2016). Parfois, je suggère même au golf de trouver des réponses dans des langues que je n’avais jamais vues auparavant. Certaines choses de base fonctionnent dans la plupart des langues. Par exemple, la semaine dernière, j'ai suggéré un golf pour une réponse T-SQL et une fois, j'ai suggéré un golf dans une réponse rouge . xD
Kevin Cruijssen le

2
44 octets utilisant lenet binau lieu de log.
Ovs



4

R , 42 octets

function(n)c(y<-2^(log2(n)%/%1)*2,2*n-y+1)

Essayez-le en ligne!

Denominator,NumeratorN=2*(n-2bûche2(n))+1=2bûche2(n)+1



3

MATL , 8 octets

BnWGEy-Q

Essayez-le en ligne!

Renvoie Numérateur, puis Dénominateur. Utilise la même méthode que ma réponse R , bien que ce soit un peu plus efficace.

Explication, avec entrée 5:

           # implicit input 5
B          # convert to array of bits
           # STACK: [[1 0 1]]
n          # length (place of Most Significant Bit)
           # STACK: [3]
W          # elementwise raise 2^x
           # STACK: [8]
G          # paste input
           # STACK: [8, 5]
E          # double
           # STACK: [8, 10]
y          # copy from below
           # STACK: [8, 10, 8]
-          # subtract
           # STACK: [8, 2]
Q          # increment
           # STACK: [8, 3]
           # implicit end of program, display stack contents

2

Langage de programmation Shakespeare , 426 octets

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:You be the sum ofyou a cat.Ford:You cat.Scene V:.Ford:Is twice you nicer I?If solet usScene X.You be twice you.Let usScene V.Scene X:.Ford:Remember twice you.You be the sum oftwice the remainder of the quotient betweenI you a cat.Open heart.You big big big big big cat.Speak thy.Recall.Open heart.You be twice the sum ofa cat a big big cat.Speak thy.Let usAct I.

Essayez-le en ligne!

Affiche la séquence indéfiniment sous la forme de deux nombres séparés par un espace, chaque élément étant séparé par une nouvelle ligne.


Aimer. LolYou be twice the sum of a cat
Cullub

En fait, c'est "deux fois la somme d'un chat, un gros chat" (c'est-à-dire 10 pour une raison quelconque).
JosiahRyanW


2

Excel 48 28 octets

Économisé 20 octets (!) Grâce à tsh

=(A1+0.5)/2^INT(LOG(A1,2))-1

= MOD (A1 + 0,5,2 ^ (INT (LOG (A1,2))))) / 2 ^ INT (LOG (A1,2))

Suppose la valeur en A1, la sortie est en décimal. Si vous souhaitez que la sortie soit sous forme de fraction, vous pouvez créer un format personnalisé pour la cellule de sortie sous la forme "0 / ### 0" et l'afficher sous forme de fraction.

Explication: Difficile à expliquer car il existe un raccourci pour accéder à cette formule. Fondamentalement, le numérateur est un décalage de bit à gauche de l'entrée et le dénominateur est la puissance suivante de 2 supérieure au nombre d'entrée.

J'ai initialement commencé avec les fonctions intégrées d'Excel pour BITLSHIFT et BITRSHIFT, mais elles déplacent les 48 bits entiers, ce qui n'est pas ce que vous voulez. Les fonctions DEC2BIN (et BIN2DEC) ont une limite de -512 à 511 (10 bits), donc cela ne fonctionnerait pas. Au lieu de cela, je devais reconstruire le nombre avec un module du nombre original, puis deux fois, puis ajouter 1 (puisque le chiffre de gauche serait toujours 1 avant un décalage).

=MOD(A1                        Use MOD for finding what the right digits are
       +0.5                    this will later add the left "1" to the right digits
           ,2^INT(LOG(A1,2)))) Take Log base 2 number of digits on the right
                               this creates the numerator divided by 2 (explained later)
/ 2^INT(LOG(A1,2))             The denominator should be 2^ (Log2 + 1) but instead of 
                               adding a 1 here, we cause the numerator to be divided by 2 instead
                               This gives us a fraction.  In the numerator, we also added .5
                               instead of 1 so that we wouldn't need to divide it in both the
                               numerator and denominator
Then tsh showed how I could take the int/log out of the mod and remove it from numerator/denominator. 

Exemples: entrez la description de l'image ici


Qu'en est- il =(A1+0.5)/2^INT(LOG(A1,2))-1?
tsh

2

C ++, 97 75 71 octets

-26 octets grâce à tsh, ceilingcat, Zacharý

float f(int i){float d=2,n=1;while(--i)n=d-n==1?d*=2,1:n+2;return n/d;}

Code de test:

std::cout << "1\t:\t" << f(1) << '\n';
std::cout << "2\t:\t" << f(2) << '\n';
std::cout << "3\t:\t" << f(3) << '\n';
std::cout << "4\t:\t" << f(4) << '\n';
std::cout << "10\t:\t" << f(10) << '\n';
std::cout << "100\t:\t" << f(100) << '\n';
std::cout << "511\t:\t" << f(511) << '\n';
std::cout << "512\t:\t" << f(512) << '\n';

Vous pouvez simplement omettre if(!i)return 0;puisque 0 n'est pas requis dans le défi.
tsh

1
En essayant de jouer au golf comme un langage. Vous devriez éviter d'utiliser whilemais essayez for. for(;exp;)est la même chose que, while(exp)mais vous pouvez y écrire deux autres déclarations. Préférer ?:au lieu de if else, qui serait plus court dans la plupart des cas.
tsh

1
Je ne pense pas que tu aies besoin du (...)tour d-n-1.
Zacharý






1

> <> , 19 18 octets

En utilisant l’idée de xnor , fixée par Jo King, -1 octet en faisant un meilleur usage des miroirs et un autre -2 octets par Jo King car elle !était superflue et ;n’est pas requise.

2*1+\1-n
2:,2/?(

Essayez-le en ligne!


Vous devriez d'abord vérifier s'il est inférieur à 2, sinon le premier élément est -0.25. Correction pour la même quantité d'octets
Jo King

Merci! J'ai également réussi à supprimer un autre octet en réutilisant les miroirs.
PidgeyUsedGust

Pourquoi avez-vous inversé la condition? 16 octets
Jo King

Je n'ai pas remarqué que cela continuerait la boucle. Sommes-nous autorisés à ne pas terminer correctement?
PidgeyUsedGust

Oui, terminer avec une erreur est acceptable tant que l'OP ne spécifie pas autrement
Jo King


1

APL (Dyalog Unicode) , 15 octets

1-⍨.5∘+÷2*∘⌊2⍟⊢

Essayez-le en ligne!

Préfixe anonyme lambda.

Merci à Adám pour 4 octets et à Cows Quack pour 2 octets.

Comment:

1-⍨.5∘+÷2*∘⌊2⍟⊢  Anonymous lambda, argument   10
            2⍟⊢  Log (⍟) of  in base 2. 210  3.32192809489...
                 Floor. 3.32192809489...  3
        2*∘       Take that power of 2. 2³  8
       ÷          Use that as denominator
   .5∘+            + 0.5  10.5. Using that as numerator: 10.5÷8  1.3125
1-⍨               Swap the arguments (⍨), then subtract. 1-⍨1.3125  1.3125-1  0.3125

1

C # (.NET Core) , 69 octets

a=>{int b=1,c=2;while(a-->1){b+=2;if(b>c){b=1;c*=2;}}return b+"/"+c;}

Essayez-le en ligne!

Ungolfed:

a=> {
    int b = 1, c = 2;   // initialize numerator (b) and denominator (c)
    while (a-- > 1)     // while a decrements to 1
    {
        b += 2;         // add 2 to b
        if (b > c)      // if b is greater than c:
        {
            b = 1;      // reset numerator to 1
            c *= 2;     // double denominator
        }
    }
    return b + "/" + c; // return fraction as string
}
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.