বাউম-মিষ্টি সিকোয়েন্স

21

বাউম-মিষ্টি সিকোয়েন্স (একটি টুইস্ট সহ A086747)

ধনাত্মক পূর্ণসংখ্যায় নিয়ে যান এবং n1 থেকে n পর্যন্ত পূর্ণসংখ্যাগুলি মুদ্রণ করুন যার জন্য বাউম-মিষ্টি ক্রমটি সত্য ফিরে আসে। বাউম-মিষ্টি ক্রমটি মিথ্যা প্রত্যাবর্তন করতে হবে যদি সংখ্যাটির বাইনারি উপস্থাপনায় সংখ্যার যে কোনও জায়গায় টানা জিরোগুলির একটি বিজোড় সংখ্যা থাকে এবং অন্যথায় সত্য হয়। আরও তথ্যের জন্য, লিঙ্কটি ক্লিক করুন। এখানে কয়েকটি উদাহরণ দেওয়া হল:

1 -> 1 -> Truthy
2 -> 10 -> Falsy
3 -> 11 -> Truthy
4 -> 100 -> Truthy (Even run of zeros)

এখানে একটি উদাহরণ দেওয়া হল n=32

পদক্ষেপ 1: বাউম-মিষ্টি ক্রমটি ভিজ্যুয়ালাইজ করা হয়েছে n=32

1               1 (1)
1 0             0 (2)
11              1 (3)
1 00            1 (4)
1 0 1           0 (5)
11 0            0 (6)
111             1 (7)
1 000           0 (8)
1 00 1          1 (9)
1 0 1 0         0 (10)
1 0 11          0 (11)
11 00           1 (12)
11 0 1          0 (13)
111 0           0 (14)
1111            1 (15)
1 0000          1 (16)
1 000 1         0 (17)
1 00 1 0        0 (18)
1 00 11         1 (19)
1 0 1 00        0 (20)
1 0 1 0 1       0 (21)
1 0 11 0        0 (22)
1 0 111         0 (23)
11 000          0 (24)
11 00 1         1 (25)
11 0 1 0        0 (26)
11 0 11         0 (27)
111 00          1 (28)
111 0 1         0 (29)
1111 0          0 (30)
11111           1 (31)
1 00000         0 (32)

সুতরাং, এন এর জন্য বাউম-সুইট সিক্যুয়েন্স গণনা করার পরে, সিকোয়েন্সের জন্য সত্যবাদী নম্বরগুলি নিয়ে চূড়ান্ত ফলাফলের জন্য তাদের সংগ্রহ করুন। আমাদের জন্য n=32হবে:

[1, 3, 4, 7, 9, 12, 15, 16, 19, 25, 28, 31]

চূড়ান্ত উত্তর হিসাবে।

এটি কোড-গল্ফ , সংক্ষিপ্ততম বাইট গণনা জয়।

code-golf  sequence  base-conversion  binary 
— ম্যাজিক অক্টোপাস উরন
সূত্র
ক) মুদ্রণ আবশ্যক, বা আমরা কেবল একটি স্ট্রিং বা অ্যারে ফিরিয়ে দিতে পারি? খ) ফলাফলগুলি কি আরোহী ক্রমে থাকতে হবে?
— এরেনসেন
@ এরিসেন যতক্ষণ না অঙ্কগুলি প্রদর্শিত হবে ততক্ষণ আমি আপনার ভাষাতে গল্ফিয়াস্টের সাথে ভাল আছি।
— ম্যাজিক অক্টোপাস উরান
2
"আরও তথ্যের জন্য, লিঙ্কটি ক্লিক করুন।" এটা প্রশ্নে রাখুন।
— বিড়াল

উত্তর:

7

05 এ বি 1 ই , 10 9 বাইট

আদনানকে একটি বাইট সংরক্ষণ করে

ƒNb00¡SP–

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ƒ          # for N in [0 ... input]
 Nb        # convert N to binary
   00¡     # split at "00"
      S    # convert to list of digits
       P   # product of list
        –  # if 1, print N
— Emigna
সূত্র
নেই ƒ পরিবর্তে কাজ >G?
— আদনান
1
@ আদনান: হ্যাঁ অবশ্যই আমি এন = 0 এড়ানোর জন্য এটি ব্যবহার করি নি, তবে এটিতে একটি বিজোড় সংখ্যক শূন্য রয়েছে তাতে কিছু আসে যায় না। আমার বোকা। ধন্যবাদ :)
— এমিগনা
@ এমিগনা আশা করছিলেন ব্যবহারটি দেখার .¡জন্য;)।
— ম্যাজিক অক্টোপাস উরন
@ কারাসোকম্পিউটিং: আমি এটি বিবেচনা করেছি, তবে দুর্ভাগ্যক্রমে আমি এর চেয়ে কম কখনও পাইনি।
— Emigna
8

জাভাস্ক্রিপ্ট (ES6), 70 68 63 বাইট

g=n=>n?g(n-1).concat(/0/.test(n.toString(2).split`00`)?[]:n):[]

console.log(g(1000).join(", "))
স্নিপেট প্রসারিত করুন

সামান্য আরও আকর্ষণীয় পুনরাবৃত্ত সমাধান:

n=>[...Array(n+1).keys()].filter(f=n=>n<2?n:n%4?n&f(n>>1):f(‌​n/4))

67 বাইট @ নীল ধন্যবাদ।

g কল করার ফাংশন।

— ETHproductions
সূত্র
এটি একটি আকর্ষণীয় পদ্ধতির, আপনি কি আগে এটি করেছেন?
— ম্যাজিক অক্টোপাস Urn
@ কারাসোকম্পুটিং এই নির্দিষ্ট ক্রমটি নয়, তবে অতীতে বেশ কয়েকবার এই ধরণের পুনরাবৃত্তি করেছি। fকোনও সংখ্যায় 1-বিটের সংখ্যা গণনা করতে আমি মাঝে মধ্যে ব্যবহার করি এমন একটি ফাংশনের মতো।
— ETH প্রোডাকশনগুলি
fব্যর্থ হয় না কখন n=0? এছাড়াও হিসাবে fশুধুমাত্র 0 বা 1 আপনি ব্যবহার দুটি বাইট বন্ধ শেভ করতে ফেরৎ n&f(n>>1)।
— নিল
@ নীল "1 থেকে n" পর্যন্ত পূর্ণসংখ্যাগুলি মুদ্রণ করুন, n = 0এটি কেস নয়;)।
— ম্যাজিক অক্টোপাস Urn
আমি আপনার পুনরাবৃত্ত সমাধানটি আরও সরিয়ে রেখেছি এতে স্যুইচ করে filter:n=>[...Array(n+1).keys()].filter(f=n=>n<2?n:n%4?n&f(n>>1):f(n/4))
— নীল
4

পাইথন 2, 62 বাইট

g=lambda n:n*[0]and g(n-1)+[n]['0'in`bin(n)[1:].split('00')`:]

বিভক্ত হয়ে বাইনারি উপস্থাপনায় 1 এর বিজোড় রানগুলির জন্য চেক 00 ফলাফলের তালিকার স্ট্রিং উপস্থাপনায় কোনও শূন্য রয়ে গেছে কিনা তা পরীক্ষা । বিরক্তিকরভাবে, বাইনারি সংখ্যাগুলি দিয়ে শুরু হয় 0b, যার একটি শূন্য থাকে যা একটি মিথ্যা ইতিবাচক এড়াতে অপসারণ করা দরকার।

পুনরাবৃত্তি করে গণনাটি করা হয়।

— xnor
সূত্র
4

ব্যাশ, 58, 46 বাইট

সম্পাদনাগুলি:

  • ডিসি দিয়ে বিসি প্রতিস্থাপন করা হয়েছে (Thx @ ডিজিটাল ট্রমা!)
  • 1 দিয়ে শুরু করুন;

Golfed

seq $1|sed 'h;s/.*/dc -e2o&p/e;s/00//g;/0/d;x'

পরীক্ষা

>./baum 32
1 
3
4
7 
9
12
15
16
19
25
28
31

ব্যাখ্যা

খোল

seq $1 #generate a sequence of integers from 1 to N, one per line
|sed   #process with sed

sed 

h                #Save input line to the hold space
s/.*/dc -e2o&p/e #Convert input to binary, with dc
s/00//g          #Remove all successive pairs of 0-es
/0/d             #If there are still some zeroes left
                 #(i.e. there was at least one odd sequence of them)
                 #drop the line, proceed to the next one
x                #Otherwise, exchange the contents of the hold 
                 #and pattern spaces and (implicitly) print

এটি অনলাইন চেষ্টা করুন!

— জেপেলীন্
সূত্র
3

ব্যাচ, 143 বাইট

@for /l %%i in (1,1,%1)do @call:c %%i
@exit/b
:c
@set/ai=%1
:l
@if %i%==1 echo %1&exit/b
@set/ar=%i%%%4,i/=4-r%%2*2
@if %r% neq 2 goto l
— নিল
সূত্র
3

পার্ল 6 , 40 বাইট

{grep {.base(2)!~~/10[00]*[1|$]/},1..$_}

চেষ্টা করে দেখুন

{
  grep            # find all of them
  {
    .base(2)      # where the binary representation
    !~~           # does not match
    /
      10          # ｢10｣
      [ 00 ]*     # followed by an even number of ｢0｣s
      [ 1 | $ ]   # either at end or before a ｢1｣
    /
  }, 1 .. $_      # from one to the input
}

( অক্ষর শ্রেণীর জন্য ব্যবহৃত [], নন-ক্যাপচারিং গ্রুপিংয়ের <[]>জন্য ব্যবহৃত হয়)

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
2

পাওয়ারশেল , 79 61 বাইট

1..$args[0]|?{0-notin([convert]::ToString($_,2)-split'1|00')}

এটি অনলাইন চেষ্টা করুন!

আমি আজ সকালে এই -splitঅপারেশনটি কীভাবে সম্পাদন করব তা পরিবর্তনের জন্য অনুপ্রেরণা পেয়েছিলাম , তারপরে দেখুন যে এক্সনরের উত্তরটি কীভাবে তৈরি করা হয়েছে তার অনুরূপ , তাই, আমি মনে করি মহান মনগুলি একই রকম মনে করে?

আমরা 1ইনপুট থেকে লুপ করি $args[0]এবং Where-Objectউপযুক্ত নম্বরগুলি বের করতে অপারেটর ব্যবহার করি |?{...}। দফা একটি সহজ বুলিয়ান মান - আমরা নিশ্চিত করছি যে 0হয় -notinফলাফল (...)।

পেরেনগুলির অভ্যন্তরে, আমরা বেসের সাথে [convert]::বর্তমান সংখ্যা (অর্থাত্ এটি বাইনারি স্ট্রিংয়ে পরিণত করি)। আমরা তখন রেজেক্সের স্ট্রিং - এটি একটি লোভী মিল, এবং ফলাফলগুলির একটি অ্যারের ফলাফল হয় (উদাহরণস্বরূপ, এর মধ্যে রূপান্তরিত হবে এবং এরকমভাবে)।$_ ToString2-split1|00100010'','','0','','0'

সুতরাং, যদি প্রতিটি রান 0বাইনারি স্ট্রিং গুলি এমনকি হয়, তাহলে (অর্থাত Regex খালি স্ট্রিং মধ্যে তাদের বিভক্ত আছে) 0হতে হবে -notin, ফলে তাই Whereদফা সত্য, এবং সংখ্যা নির্বাচন করা হয়। এই সংখ্যাগুলি পাইপলাইনে রেখে গেছে এবং আউটপুট অন্তর্ভুক্ত।

— AdmBorkBork
সূত্র
2

পাইথন 2 , 67 47 বাইট

f=lambda n,k=1:n/k*[1]and[k]+f(n,k-~k)+f(n,4*k)

@ Xnor কে ২০ (!) বাইট বন্ধ করে দেওয়ার জন্য ধন্যবাদ!

একটি আনর্ডারড তালিকা ফিরিয়ে দেয়। এটি বেশ দক্ষ: ইনপুট 100,000 টিআইওতে প্রায় 40 এমএস লাগে ms

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র
দুর্দান্ত পদ্ধতি! আমি মনে করি আপনি যেমন বেস কেস করতে পারেন [1][n:]or। এছাড়াও, x-~xজন্য 2*x+1।
— xnor
আপনি যদি এর পরিবর্তে গাছটিকে f=lambda n,k=1:n/k*[1]and[k]+f(n,k-~k)+f(n,4*k)পুনরুক্ত করেন তবে এটি খুব পরিষ্কার সমাধান দেয় :, ধরে নেওয়া যে আউটপুটগুলি যে কোনও ক্রম হতে পারে।
— xnor
@ xnor এটি ক্রেজি ধন্যবাদ!
— ডেনিস
1

এমএটিএল , 12 11 বাইট

:"@BY'og)?@

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কোনও সংখ্যাটি বৈধ কিনা এটি সনাক্ত করতে এটি বাইনারিতে রূপান্তরিত করে, রান-লেংথ এনকোডিং প্রয়োগ করে, কেবল বিজোড় দৈর্ঘ্যের রান রাখে এবং শূন্যের কোনও রান বেঁচে নেই কিনা তা পরীক্ষা করে।

:       % Take input n implicitly. Push range [1 2 ... n]
"       % For each k in [1 2 ... n]
  @     %   Push k
  B     %   Convert to binary
  Y'    %   Run-length encoding. Pushes array of values and array of run-lengths
  o     %   Parity. Gives array that contains 0 for even lengths, 1 for odd
  g)    %   Convert to logical and use index into the array of values
  ?     %   If the result does not contain zeros
    @   %     Push k
        %   End
        % End
        % Implicitly display stack
— লুইস মেন্ডো
সূত্র
স্পষ্টতার জন্য সম্পাদিত প্রশ্নে আমি বুঝতে পেরেছিলাম যে কিছু লোক কেবল ওইআইএস ক্লিক করবে এবং সেখান থেকে না পড়েই যাবে; পি। এটাই আমি মাঝে মাঝে খুব হাহ করি।
— ম্যাজিক অক্টোপাস Urn
@ কারাসোকম্পুটিং হ্যাঁ, আমি সবসময় খুব দ্রুত পড়ে থাকি :)
— লুইস মেন্ডো
1

আর, 75 বাইট

for(i in 1:scan()){x=rle(miscFuncs::bin(i));if(!any(x$l%%2&!x$v))cat(i,"")}

দশম থেকে বাইনারি ভেক্টরে রূপান্তর করতে স্টিডিনের ইনপুট পড়ে এবং প্যাকেজ binথেকে ফাংশনটি ব্যবহার করে miscFuncs। ফলস্বরূপ মানগুলি == 0এবং দৈর্ঘ্যগুলি বিজোড় হয় তা পরীক্ষা করতে রান-লেংথ এনকোডিং সম্পাদন করে ।

— Billywob
সূত্র
1

সারিবদ্ধ , 69 বাইট

এখানে চেষ্টা করুন!

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all]"filter

বা, 67 বাইটে নন-কেপটিং:

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap even all]"filter

এবং, 49 বাইটে আরও নন-কেপেটিং:

:>1+[bits rle{k:k 0=}filter values even all]fkeep

সমস্ত টিওএস হিসাবে ইনপুট নেয় এবং টিওএস এ আউটপুট ছেড়ে যায়।

ব্যাখ্যা

:>1+[...]"filter   input: n
:>                 range from [0, n)
  1+               range from [1, n]
    [...]          a function
         "filter   apply to each cell and filter

কাজ:

bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all  input: c
bits                                                      convert c to binary
    {e.b:e b 0#=}chunkby                                  split into chunks of contiguous 0s
                        [0 has]filter                     take only chunks with 0s
                                     $sizemap             map each chunk to its size
                                              2%          vectorized modulus 2
                                                0 eq      vectorized equality with 0
                                                     all  all of them are of even lengths

নন-কার্পেটের ব্যাখ্যা:

কয়েকটি মূল পার্থক্য সহ এটি উপরের মতোই:

:>1+[bits rle{k:k 0=}filter values even all]fkeep   input: y
          rle                                       run length encode y
             {k:k 0=}filter                         keep keys that = 0
                            values                  get those values
                                            fkeep   like `filter`, but is implemented with
                                                    taking `f` as a boolean mask
— কনর ও ব্রায়ান
সূত্র
স্ট্যাকড দেখে মনে হচ্ছে এটি খেলতে মজাদার হতে পারে!
— এলপেড্রো
@ এলপেড্রো ধন্যবাদ: ডি এটি সত্যই
— ও'ব্রায়েন
1

বেফুঞ্জ, 84 51 49 বাইট

কিছুটা পরীক্ষার পরে, আমি বুঝতে পেরেছিলাম যে নীল যে ব্যাচের উত্তর নিয়ে এসেছিল, তার অনুরূপ একটি কৌশল ব্যবহার করে আমি আমার মূল সমাধানের চেয়ে বেশ কিছুটা ভাল করতে পারি ।

<v::\<&1
:_v#:/+2*2!%2:_v#-2%4
:$<@_v#!:-1\+1$<:.

এটি অনলাইন চেষ্টা করুন!

আমার আসল সমাধান হিসাবে, দুটি লুপ রয়েছে - আমরা পরীক্ষা করতে চাই এমন সংখ্যার উপর দিয়ে আবর্তিত বহিরাগত লুপ এবং প্রতিটি সংখ্যার জন্য বিট ক্রমটি পরীক্ষা করে একটি অভ্যন্তরীণ লুপ। পরীক্ষাটি যেভাবে কাজ করে তা হ'ল একসাথে দুটি বিট পরীক্ষা করে (বর্তমান মানটির 4 টি মডেল)। যদি এটি 2 এর সমান হয় তবে আমরা জিরোগুলির একটি বিজোড় ক্রম পেয়েছি এবং অভ্যন্তরীণ লুপটি বাতিল করতে এবং পরবর্তী সংখ্যাটিতে যেতে পারি।

যদি মডুলো 4 2 এর সমান না হয়, তবে আমাদের বাকী বিটগুলি পরীক্ষা করে চালিয়ে নেওয়া দরকার, তাই আমরা ইতিমধ্যে পরীক্ষিত বিটগুলি স্থানান্তর করব। এটি মানটি ভাগ করেই করা হয়, এটি কল করতে দিন এন দ্বারা2+2*!(n%2) । এর অর্থ যদি প্রথম বিটটি 1 ছিল, আমরা 2 দিয়ে বিভক্ত হয়েছি (সেই 1 বিটটি বাদ দিচ্ছি), তবে এটি যদি 0 হয়, আমরা 4 দিয়ে বিভক্ত করি, তাই আমরা সর্বদা জোড়া শূন্যকে ফেলে যাব।

যদি আমরা শেষ পর্যন্ত শূন্যে নেমে যাই তবে এর অর্থ শূন্য বিটের কোনও বিজোড় অনুক্রম ছিল না, তাই আমরা সংখ্যাটি লিখি।

— জেমস হোল্ডারেন্স
সূত্র
1

ভিজ্যুয়াল বেসিক (। নেট 4.5) 163 বাইট

প্রথমে এখানে উত্তর দিন যাতে আমি নিশ্চিত যে আমি কিছু ভুল করেছি। আমাকে জানিয়ে দিন এবং আমি ঠিক করব। ভিজ্যুয়াল বেসিক ল্যাম্বডাস কি এমনকি অনুমোদিত?

ক্রমাগত শূন্য ধারণাটি অপসারণ করার জন্য মামাফুনরলকে ধন্যবাদ

Dim R=Sub(m)System.Console.WriteLine(String.Join(",",System.Linq.Enumerable.Range(1, m).Where(Function(s) Not Convert.ToString(s,2).Replace("00","").Contains(0))))

আর (32) আউটপুট 

1,3,4,7,9,12,15,16,19,25,28,31
— প্রেতাত্মা
সূত্র
1

জাভা, 144 130 128 বাইট

এটি যেমনটি হতে পারে আমার মনে হয় ততটা গল্ফ নয়, তবে আমি ভেবেছিলাম যে এটি কখনও ব্যবহার না করেও রেইজেক্স ব্যবহারের জন্য এটি একটি সুন্দর সমাধান হতে পারে।

Golfed:

static String a(int n){String s="";for(Integer i=0;i++<n;)if(i.toString(i,2).replaceAll("00|1","").isEmpty())s+=i+" ";return s;}

Ungolfed:

static String a(int n){
    String s="";                      //Cheaper than using a list/array
    for(Integer i=0;i++<n;)           //Loop n times
        if(i.toString(i,2)            //Convert int to base 2 string
                .replaceAll("00|1","")//Find and remove ones and consecutive zeroes
                .isEmpty())           //If any chars remain, i is truthy
            s+=i+" ";                 //Append i to the storage string
    return s;                         //Return all values
}

সম্পাদনা করুন: আমি 00 এর পরিবর্তে রেজেক্স 00 | 1 তৈরি করে এবং প্রতিস্থাপনের সমস্ত এবং ইস্পটির মধ্যে ".রেপ্লেস (" 1 "," ")" সরিয়ে 14 বাইট সংরক্ষণ করতে সক্ষম হয়েছি!

2 সম্পাদনা করুন: আমি একটি পূর্ণসংখ্যা তৈরি করে এবং i.toString দিয়ে পূর্ণসংখ্যা.টোস্ট্রিং উল্লেখ করে 2 বাইট সংরক্ষণ করতে সক্ষম হয়েছি।

— Zavada
সূত্র
@ জেমসহোল্ডারেন্স এটি ধরার জন্য ধন্যবাদ! আমি যখন এটি প্রথম লিখছিলাম তখন আমি কয়েকবার গল্ফ করা এবং উগলফুল করার ভুল করেছিলাম, সুতরাং এটি অবশ্যই এইভাবেই ছড়িয়ে পড়ে।
— জাভাদা
0

ক্লোজার, 103 বাইট

আমি মনে করি না এটি সবচেয়ে সংক্ষিপ্ততম উপায় ...

#(remove(fn[v]((set(map(fn[s](mod(count s)2))(re-seq #"0+"(Integer/toString v 2))))1))(range 1(inc %)))

re-seqএকটানা শূন্য খুঁজে পেতে ব্যবহার করে, তাদের মডুলো -2 দৈর্ঘ্য একটিতে মানচিত্র করে set, 1সেট থেকে নম্বর খুঁজে পাওয়া গেলে তাদের এড়িয়ে যায়।

— NikoNyrh
সূত্র
0

আশ্চর্য , 38 বাইট

@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0

ব্যবহার:

(@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0) 32

ব্যাখ্যা

আরও পঠনযোগ্য:

@(
  fltr@
    = 1 
      len 
        iO 0 
          Rstr #["00"] 
            bn #0
) rng 1 +1 #0

rng 1 +1 #0: 1 থেকে ইনপুট পর্যন্ত ব্যাপ্তি।

fltr@ ...: নিম্নোক্ত ভবিষ্যদ্বাণী সহ ফিল্টার পরিসীমা

bn #0: বর্তমান আইটেমটিকে বাইনারি রূপান্তর করুন। (এটি একটি নেতৃস্থানীয় হবে 0b)।

Rstr #["00"]: 00স্ট্রিংয়ের যেকোন ঘটনা পুনরাবৃত্তভাবে ছাঁটাই করুন ।

len iO 0: 0স্ট্রিংয়ের পরিমাণগুলি গণনা করুন ।

=1: পরিমাণটি 1 এর সমান কিনা তা পরীক্ষা করে দেখুন 0ছাঁটাইয়ের পরে যদি স্ট্রিংয়ের মধ্যে কেবলমাত্র বাম অগ্রণী হয় 0b, তবে এটি সত্য ফিরে আসে; অন্যথায়, এটি মিথ্যা প্রত্যাবর্তন করে।

— মামা ফান রোল
সূত্র
0

রুবি, 78 69 68 বাইট

->n{(1..n).select{|m|m.to_s(s=2).split(?1).map{|i|s|=i.size};s&1<1}}

পুরানো সংস্করণ:

->n{(1..n).select{|m|m.to_s(2).split(?1).select{|i|i.size%2>0}[0].!}}
->n{(1..n).select{|m|b=z=0;(m.to_s(2)+?1).each_char{|i|z+=i>?0?b|=z:1};b&1<1}}
— DepressedDaniel
সূত্র
0

গণিত, 81 বাইট

Select[Range@#,FreeQ[Union@#+Mod[Length@#,2,1]&/@Split[#~IntegerDigits~2],{1}]&]&

সংখ্যায় ক্রমাগত অঙ্কের প্রতিটি রানের জন্য গণনাগুলি {সেই রান প্লাসের সাধারণ সংখ্যা (1 দৈর্ঘ্য বিজোড় হলে 2, দৈর্ঘ্য সমান হলে 2)}; উত্তরগুলির মধ্যে যদি কোনও {1 is হয় তবে সংখ্যাটি ক্রম নয়।

— গ্রেগ মার্টিন
সূত্র
0

গণিত, 75 বাইট

Select[Range@#,And@@EvenQ/@Length/@Cases[Split[#~IntegerDigits~2],{0..}]&]&

#~IntegerDigits~2ইনপুটটির বাইনারি সংখ্যাগুলির তালিকা গণনা করে #। Splitসেই তালিকাটিকে অভিন্ন উপাদানগুলির রানের মধ্যে ফেলেছে, Casesসেই ম্যাচটি {0..}গ্রহণ Lengthকরুন, তাদের প্রত্যেকের সাথে নিন, EvenQদৈর্ঘ্য নিন এবং তারপরে Andফলাফলগুলি ফিরে আসুন ।

— ngenisis
সূত্র
1
একটি বাইট সংরক্ষণ আপনার সমাধান থেকে নিতে পারেন:!Or@@OddQ/@...
— মার্টিন ইন্ডার
0

পাইথন 3, 86 82 বাইট

গল্ফিং চলছে ...

lambda n:[x for x in range(1,n+1)if 1-any(i%2for i in map(len,bin(x).split('1')))]

bin(x)[2:]মাত্র পরিবর্তন করে ৪ টি বাইট বন্ধ করে দেওয়া bin(x)- 0bস্ট্রিংয়ের শুরুতে এই পাতাটি , তবে আমি বুঝতে পেরেছি এটি আসলে গণনাগুলিকে প্রভাবিত করে না :)

— FlipTack
সূত্র
0

পাইথন, 142 বাইট

এটি মূলত আমার পাইথনকে গল্ফ করার অনুশীলন করার জন্য।

def o(n):
 r=0
 for i in bin(n)[2:]:
  if i=='1':
   if r&1:return 0
   r=0
  else:r+=1
 return ~r&1
lambda n:[i for i in range(1,n+1)if o(i)]
— Noodle9
সূত্র
0

রুবি, 54 53 48 বাইট

->n{(1..n).reject{|x|x.to_s(2)=~/10(00)*(1|$)/}}

আমি মনে করি না এর জন্য রেজেেক্সটি এতটা বেসিক হয়ে উঠবে।

সম্পাদনা 1: -1 এর জন্য অবহেলা থেকে মুক্তি পেতে প্রত্যাখ্যান করতে স্যুইচ করা হয়েছে।

সম্পাদনা 2: -5-এ স্যুইচ matchকরা =~হয়েছে।

— Elenian
সূত্র
0

সি # 159 157 155 বাইট

টুকুএক্সএক্সকে 2 এক্স টু বাইট সংরক্ষণ করা হয়েছে।

দ্রষ্টব্য: বিপরীত ক্রমে ints মুদ্রণ।

void B(int n){var b=Convert.ToString(n,2);int c=0,i=0;for(;i<b.Length;){if(b[i++]<49)c++;else if(c%2>0)break;}if(c%2<1)Console.WriteLine(n);if(n>1)B(--n);}

ব্যাখ্যা:

void B(int n)
{
    // convert our int to a binary string
    var b = Convert.ToString(n, 2);

    // set our '0' counter 'c' and our indexer 'i' 
    int c = 0, i = 0;

    // loop over the binary string, without initialisation and afterthought
    for (; i < b.Length;)
    {
        // check for '0' (48 ASCII) and increment i. increment c if true
        if (b[i++] < 49)
            c++;

        // otherwise check if c is odd, and break if it is
        else if (c%2 > 0)
            break;
    }

    // print the int if c is even
    if (c%2 < 1)
        Console.WriteLine(n);

    // recursively call B again with the next number
    if (n > 1)
        B(--n);
}
— Erresen
সূত্র
প্রথম নজরে, c%2==0হতে পারে c%2<1।
— Yytsi
ওহ অপেক্ষা করুন, এটি এমনকি একটি বৈধ জমা নেই। এটি 1 থেকে সঠিক ফলাফল মুদ্রণ করা উচিত N।
— Yytsi
@ টুকুএক্স অবশ্যই প্রশ্নটি ভুলভাবে পড়ে থাকতে হবে ... এখনই উত্তর সংশোধন করছে।
— এরেসেন
@ টুকুকএক্স সম্পাদিত এবং জমা দেওয়া হয়েছে
— এরেসেন
1
b[i++] == '0'হতে পারে b[i++]==48, তবে যেহেতু অন্যান্য সম্ভাব্য চরিত্রটি '1' (এএসসিআইআই 49), তাই আপনি কেবল এটি পরীক্ষা করতে পারেন b[i++]<49।
— Yytsi
0

গণিত, 69 বাইট

Select[Range@#,FreeQ[#~IntegerDigits~2//.{x___,0,0,y___}:>{x,y},0]&]&

একই দৈর্ঘ্য:

Select[Range@#,#~IntegerString~2~StringDelete~"00"~StringFreeQ~"0"&]&
— alephalpha
সূত্র
0

জেলি, 15 13 10 বাইট

অন্যান্য উত্তরগুলি দেখার পরে দুটি বাইট সংরক্ষণ করা, ডেনিসকে আরও 3 বাইট ধন্যবাদ

Bœṣ0,0Ȧµ€T

ব্যাখ্যা

Bœṣ0,0Ȧµ€T -Helper link: argument K (integer): ex. 24
B          -Convert K to a list of its binary digits: 24 -> [1,1,0,0,0]
   0,0     -Create a list of two 0's: [0,0]
 œṣ        -Split the binary digits on instances of the sublist: [1,1,0,0,0]-> [[1,1],[0]]
      Ȧ    -Any and All: Check if our list has any falsy values or is empty
       µ   -Take all our previous atoms and wrap them into one monad.
        €  -Map this new monad over a list. Since our input is an integer, this implicitly maps it over the range [1..N] (Like the 'R' atom)
         T -Get the indices of all truthy values (1's)
— Xanderhall
সূত্র
tio.run/nexus/jelly#ARcA6P//QsWT4bmjMCwwyKbCteKCrFT///8zMg 3 বাইট সাশ্রয় করে
— ডেনিস
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.