태스크

이진 표현에 둘 이상의 런이 1하나 이상 분리 되어 포함되도록 숫자 집합을 찾습니다 0.

예를 들어, 길이가 4 비트 인 숫자의 경우 :

 0 0000        (no ones)
 1 0001        (only one run)
 2 0010        (only one run)
 3 0011        (only one run)
 4 0100        (only one run)
 5 0101 Valid
 6 0110        (only one run)
 7 0111        (only one run)
 8 1000        (only one run)
 9 1001 Valid
10 1010 Valid
11 1011 Valid
12 1100        (only one run)
13 1101 Valid
14 1110        (only one run)
15 1111        (only one run)

입력

범위 내의 일부 입력을 통해 응용 프로그램에 제공되는 정수 3 .. 32입니다. 이것은 계산할 최대 비트 수를 나타냅니다.

입력은 n숫자 를 검사해야 함을 나타냅니다 .0 .. 2n-1

산출

기준을 충족하는 모든 숫자의 구분 된 (선택한) 목록. 숫자는 숫자 순서대로 표시됩니다. 추가 후행 구분 기호가 허용됩니다. 데이터 구조 엔클로저 (예 : []유사한)도 허용됩니다.

예

Input: 3
Output: 5

Input: 4
Output: 5, 9, 10, 11, 13

Input: 5
Output: 5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29

이것은 코드 골프입니다 -가장 적은 바이트 수의 답이 이깁니다.

Pyth, 12 바이트

f<2r.BT8U^2Q

온라인으로 사용해보십시오.

생각

양수의 이진 표현은 항상 1 초의 실행으로 시작하며 그 뒤에 다른 0 및 1 의 대체 실행이 이어질 수 있습니다 . 최소 세 개의 런이있는 경우 그 중 두 런은 1 s의 런임을 보장합니다 .

암호

              (implicit) Store the evaluated input in Q.
         ^2Q  Calculate 2**Q.
f       U     Filter; for each T in [0, ..., 2**Q-1]:
    .BT         Compute T's binary representation.
   r   8        Perform run-length encoding.
                This returns a list of character/run-length pairs.
 <2             Discard the trailing two pairs.
                This returns a non-empty array if there are more than 2 runs.
              Keep T if the array was truthy (non-empty).

파이썬, 48

lambda n:[i for i in range(2**n)if'01'in bin(i)]

나는 이것을 너무 많이 생각하고 있었다. 이진 확장에 포함되어 있는지 확인하면됩니다 '01'.

두 개의 런이 있으려면 오른쪽의 런 앞에 a가 있어야합니다 0. 런이 하나 뿐인 경우 선행 0이 없어서 발생하지 않습니다.

이전 답변 :

lambda n:[i for i in range(2**n)if len(set(bin(i).split('0')))>2]

파이썬 바이너리 표현은 여기서 아주 잘 작동합니다. 이진수는 다음과 같이 작성 bin(9)=='0b10110'됩니다. '0'결과를 나누면

• 이니셜의 왼쪽 0, 연속 된 두 연속 사이 0및 마지막 오른쪽에 빈 문자열0
• b하나 이상의 주요 문자가 뒤 따르는 문자
• 의 실행 1선두되지 않습니다들 '

처음 두 범주는 항상 존재하지만, 런가있는 경우 마지막에만 존재하는 1'선도 포함되어 있지 않습니다들 '1', 그리고 하나 개 이상의 실행있을 경우에만 수정 1들'. 따라서 목록에 2고유 한 요소 보다 많은 요소 가 포함되어 있는지 확인하면 충분합니다 .

Python 3.5는 {*_}대신 에 압축을 풀어 2 개의 문자를 저장 set(_)합니다.

루비, 44 40 38 자

^{44를 넘어 서면 여전히 규칙적이다 .44; (}

->n{(0..2**n).select{|x|/01/=~'%b'%x}}

정수를 취하고 배열을 반환하는 익명 함수 (실제로 프록)입니다.

정규식을 사용합니다 /10+1/. a 1, 최소한 하나 이상 0, 다른 하나 1. @histocrat 01은 문자열의 아무 곳에 나 있으면 그 앞에 어딘가 가 있어야 한다고 지적 합니다1 .

줄리아, 43 41 바이트

n->filter(i->ismatch(r"01",bin(i)),1:2^n)

정수를 받아들이고 배열을 반환하는 명명되지 않은 함수를 만듭니다. 히스 토크 라트의 정규 표현식 트릭 (도어 노브의 답변에 사용됨)을 사용하며 01, 앞의 1이있는 경우에만 일치합니다.

언 골프 드 :

function f(n::Int)
    # Take the integers from 1 to 2^n and filter them down to
    # only those such that the binary representation of the integer
    # matches the regex /01/.
    filter(i -> ismatch(r"01", bin(i)), 1:2^n)
end

MATLAB, 79 68 64 59

아이디어는 이진수를 0과 1의 배열로 해석 한 다음 각 이웃 쌍 간의 절대 차이를 계산합니다. 우리가 1의 차이를 두 번 이상 가지고 있다면 분명히 두 개 이상의 런이 있습니다. 이것은 선행 0이없는 이진수를 나타내는 경우에만 작동합니다.

@(n)find(arrayfun(@(k)sum(~~diff(dec2bin(k)+0))>1,1:2^n-1))

이전 버전 :

k=1:2^input('')-1;k(arrayfun(@(k)sum(~~diff(dec2bin(k)+0))>1,k))

for k=1:2^input('')-1;if sum(~~diff(dec2bin(k)+0))>1;disp(k);end;end

for k=1:2^input('')-1;if sum(~~conv(dec2bin(k)+0,[-1,1],'v'))>1;disp(k);end;end

자바 스크립트 (ES7), 89 85 72 69 62 바이트

JS에서 범위를 만드는 성스러운 소는 쉽지 않습니다. 아마도 실제 for루프 에서는 더 짧을 것 입니다. 아니, 나는 거짓말했다. 실제로 조금 더 깁니다. 오 잘 27 바이트를 절약해야합니다. (Mwr247 덕분에 7 개!)

x=>[for(a of Array(1<<x).keys())if(/01/.test(a.toString(2)))a]

최신 버전의 Firefox에서는 제대로 작동하지만 다른 브라우저에서는 작동하지 않을 수 있습니다. 사용해보십시오 :

<!--                               Try the test suite below!                              --><strong id="bytecount" style="display:inline; font-size:32px; font-family:Helvetica"></strong><strong id="bytediff" style="display:inline; margin-left:10px; font-size:32px; font-family:Helvetica; color:lightgray"></strong><br><br><pre style="margin:0">Code:</pre><textarea id="textbox" style="margin-top:5px; margin-bottom:5px"></textarea><br><pre style="margin:0">Input:</pre><textarea id="inputbox" style="margin-top:5px; margin-bottom:5px">5</textarea><br><button id="testbtn">Test!</button><button id="resetbtn">Reset</button><br><p><strong id="origheader" style="font-family:Helvetica; display:none">Original Code Output:</strong><p><div id="origoutput" style="margin-left:15px"></div><p><strong id="newheader" style="font-family:Helvetica; display:none">New Code Output:</strong><p><div id="newoutput" style="margin-left:15px"></div><script type="text/javascript" id="golfsnippet">var bytecount=document.getElementById("bytecount");var bytediff=document.getElementById("bytediff");var textbox=document.getElementById("textbox");var inputbox=document.getElementById("inputbox");var testbtn=document.getElementById("testbtn");var resetbtn=document.getElementById("resetbtn");var origheader=document.getElementById("origheader");var newheader=document.getElementById("newheader");var origoutput=document.getElementById("origoutput");var newoutput=document.getElementById("newoutput");textbox.style.width=inputbox.style.width=window.innerWidth-50+"px";var _originalCode="x=>[for(a of Array(1<<x).keys())if(/01/.test(a.toString(2)))a]";function getOriginalCode(){if(_originalCode!=null)return _originalCode;var allScripts=document.getElementsByTagName("script");for(var i=0;i<allScripts.length;i++){var script=allScripts[i];if(script.id!="golfsnippet"){originalCode=script.textContent.trim();return originalCode}}}function getNewCode(){return textbox.value.trim()}function getInput(){try{var inputText=inputbox.value.trim();var input=eval("["+inputText+"]");return input}catch(e){return null}}function setTextbox(s){textbox.value=s;onTextboxChange()}function setOutput(output,s){output.innerHTML=s}function addOutput(output,data){output.innerHTML+='<pre style="background-color:'+(data.type=="err"?"lightcoral":"lightgray")+'">'+escape(data.content)+"</pre>"}function getByteCount(s){return(new Blob([s],{encoding:"UTF-8",type:"text/plain;charset=UTF-8"})).size}function onTextboxChange(){var newLength=getByteCount(getNewCode());var oldLength=getByteCount(getOriginalCode());bytecount.innerHTML=newLength+" bytes";var diff=newLength-oldLength;if(diff>0){bytediff.innerHTML="(+"+diff+")";bytediff.style.color="lightcoral"}else if(diff<0){bytediff.innerHTML="("+diff+")";bytediff.style.color="lightgreen"}else{bytediff.innerHTML="("+diff+")";bytediff.style.color="lightgray"}}function onTestBtn(evt){origheader.style.display="inline";newheader.style.display="inline";setOutput(newoutput,"");setOutput(origoutput,"");var input=getInput();if(input===null){addOutput(origoutput,{type:"err",content:"Input is malformed. Using no input."});addOutput(newoutput,{type:"err",content:"Input is malformed. Using no input."});input=[]}doInterpret(getNewCode(),input,function(data){addOutput(newoutput,data)});doInterpret(getOriginalCode(),input,function(data){addOutput(origoutput,data)});evt.stopPropagation();return false}function onResetBtn(evt){setTextbox(getOriginalCode());origheader.style.display="none";newheader.style.display="none";setOutput(origoutput,"");setOutput(newoutput,"")}function escape(s){return s.toString().replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}window.alert=function(){};window.prompt=function(){};function doInterpret(code,input,cb){var workerCode=interpret.toString()+";function stdout(s){ self.postMessage( {'type': 'out', 'content': s} ); }"+" function stderr(s){ self.postMessage( {'type': 'err', 'content': s} ); }"+" function kill(){ self.close(); }"+" self.addEventListener('message', function(msg){ interpret(msg.data.code, msg.data.input); });";var interpreter=new Worker(URL.createObjectURL(new Blob([workerCode])));interpreter.addEventListener("message",function(msg){cb(msg.data)});interpreter.postMessage({"code":code,"input":input});setTimeout(function(){interpreter.terminate()},1E4)}setTimeout(function(){getOriginalCode();textbox.addEventListener("input",onTextboxChange);testbtn.addEventListener("click",onTestBtn);resetbtn.addEventListener("click",onResetBtn);setTextbox(getOriginalCode())},100);function interpret(code,input){window={};alert=function(s){stdout(s)};window.alert=alert;console.log=alert;prompt=function(s){if(input.length<1)stderr("not enough input");else{var nextInput=input[0];input=input.slice(1);return nextInput.toString()}};window.prompt=prompt;(function(){try{var evalResult=eval(code);if(typeof evalResult=="function"){var callResult=evalResult.apply(this,input);if(typeof callResult!="undefined")stdout(callResult)}}catch(e){stderr(e.message)}})()};</script>

^{( 이 페이지 에서 가져온 스 니펫 )}

제안을 환영합니다!

하스켈, 68 61 53 바이트

Damien에서 개선

g x|x`mod`4==1=x>4|2>1=g$x`div`2
a x=filter g[1..2^x]

역사:

이것은 버그를 수정합니다 (Switched == 및 = 및 2의 제곱 대신 제곱). true를 2> 1로 바꾸고 false를 1> 2로 바꾸십시오. 또한 2 ^ x는 항상 실패한다는 것을 지적했습니다. 토마스 콰과 니미 덕분에

g x|x<5=1>2|x`mod`4==1=2>1|2>1=g$x`div`2
a x=filter g[1..2^x]

원래

g x|x<5=False|x`mod`4=1==True|2>1=g$x`div`2
a x=filter g[1..(x^2-1)]

풀 프로그램이어야한다면

g x|x<5=False|x`mod`4==1=True|2>1=g$x`div`2
main=interact$show.a
a x=filter g[1..2^(read x)]

APL, 34 27 바이트

{0~⍨{⍵×2<+/2≢/⍵⊤⍨⍵/2}¨⍳2*⍵}

오른쪽의 정수를 받아들이고 배열을 반환하는 명명되지 않은 monadic 함수를 만듭니다.

설명:

                     }¨⍳2*⍵}  ⍝ For each integer from 1 to 2^input...
              ⍵⊤⍨⍵/2         ⍝ Get the binary representation as a vector
           2≢/                ⍝ Pairwise non-match, yielding a boolean vector
       2<+/                   ⍝ Check whether the number of trues is >2
     ⍵×                       ⍝ Yield the integer if so, otherwise 0
{0~⍨{                         ⍝ Remove the zeros from the resulting array

Dennis 덕분에 7 바이트가 절약되었습니다!

R, 55 47 바이트

(@ Alex.A의 도움으로)

cat(grep("10+1",R.utils::intToBin(1:2^scan())))

R에는 편리한 방법으로 변환 된 숫자를 표시하는 기능이 내장되어 있지 않으므로이 기능을 사용 R.utils::intToBin하고 있지만 나머지는 일치하는 정규 표현식의 위치를 ​​거의보고하고 STDOUT으로 인쇄합니다. 공간.

CJam, 14

2qi#{2b2,#)},p

Dennis 덕분에 3 바이트 더 짧았습니다. 온라인으로 사용해보십시오

자바 스크립트 (ES6), 69 68 67 62 바이트

a=>[...Array(1<<a).keys()].filter(i=>/01/.test(i.toString(2)))

오늘 필은 채우기 나 맵을 사용하지 않고 배열을 동적으로 채울 수있는 새로운 방법을 발견했습니다. 그렇게하면 x=>[...Array(x).keys()]0에서 x 범위의 배열이 반환됩니다. 고유 한 범위 / 값을 정의하려면 x=>[...Array(x)].map((a,i)=>i)몇 바이트 만 더 길기 때문에를 사용하십시오.

자바 214 165 155 154 148 141 110 바이트

이 제출은 Java에서 숫자의 이진 문자열 표현이 선행 0을 갖지 않는다는 사실을 이용합니다. 문자열 "01"이 숫자의 이진 표현으로 나타나면 두 번째 숫자 "1"을 표시 해야합니다 .

골프 :

String f(int l){String r="";for(long i=5;i<1L<<l;++i)if(Long.toString(i,2).contains("01"))r+=i+", ";return r;}

언 골프 드 :

public class NumbersWithMultipleRunsOfOnes {

  public static void main(String[] a) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "3", "5" },
      { "4", "5, 9, 10, 11, 13" },
      { "5", "5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new NumbersWithMultipleRunsOfOnes().f(Integer.parseInt(data[0])));
      System.out.println();
    }
  }

  // Begin golf
  String f(int l) {
    String r = "";
    for (long i = 5; i < 1L << l; ++i)
      if (Long.toString(i, 2).contains("01")) r += i + ", ";
    return r;
  }
  // End golf
}

프로그램 출력 (후행 구분 기호를 사용할 수 있음을 기억하십시오) :

Input: 3
Expected: 5
Actual:   5, 

Input: 4
Expected: 5, 9, 10, 11, 13
Actual:   5, 9, 10, 11, 13, 

Input: 5
Expected: 5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29
Actual:   5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29, 

C (gcc) , 111 99 바이트

long i,x;main(a,b)char**b;{for(;++i<1L<<atol(b[1]);x>>ffsl(~x)-1&&printf("%ld,",i))x=i>>ffsl(i)-1;}

온라인으로 사용해보십시오!

@ceilingcat 덕분에 12 바이트가 줄었습니다!

언 골프 드 :

int main(int a, char **b) {
  for(long i = 0, x = 0; ++i < (1LL << atol(b[1])); ) {
    x = i >> (ffsl(i) - 1);
    if (x >> (ffsl(~x) - 1))
      printf("%ld,", i);
  }
}

ffsl () 함수는 긴 정수로 설정된 첫 번째 비트의 인덱스를 제공합니다. 따라서 i = 12 ^ number_of_bits로 반복 합니다. 가장 중요하지 않은 끝에서 모든 연속 0 비트를 제거 할 때까지 오른쪽 x으로 i이동 하도록 설정 했습니다. 그런 다음 x가장 중요한 끝 부분에서 연속적인 1 비트를 모두 제거 할 때까지 오른쪽으로 이동 합니다. 결과가 여전히 0이 아닌 경우 일치하는 것을 발견했습니다.

자바 스크립트 (ES6) 76

f=n=>Array(1<<n).fill().map((_,x)=>/01/.test(x.toString(2))?x+',':'').join``

//TEST
for(i=1;i<16;i++)O.innerHTML+=i+' -> '+f(i)+'\n'

<pre id=O></pre>

K5, 19 바이트

이는 Dennis 솔루션과 유사한 원칙에 따라 작동하지만 활용할 수있는 기본 기능이 적습니다.

{&2<+/'~0=':'+!x#2}

먼저 일련의 이진 x 튜플 ( +!x#2)을 생성 한 다음이 튜플마다 목록의 -1st 요소를이 목적으로 ( ~0=':') 로 0으로 취급하면 숫자가 이전과 일치하지 않는 모든 지점을 찾습니다 . 우리의 솔루션은 2가 각 실행 횟수의 합보다 작은 곳입니다. ( &2<+/').

각 중간 단계를 표시하는 것이 더 명확합니다.

  4#2
2 2 2 2

  !4#2
(0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1)

  +!4#2
(0 0 0 0
 0 0 0 1
 0 0 1 0
 0 0 1 1
 0 1 0 0
 0 1 0 1
 0 1 1 0
 0 1 1 1
 1 0 0 0
 1 0 0 1
 1 0 1 0
 1 0 1 1
 1 1 0 0
 1 1 0 1
 1 1 1 0
 1 1 1 1)

  ~0=':'+!4#2
(0 0 0 0
 0 0 0 1
 0 0 1 1
 0 0 1 0
 0 1 1 0
 0 1 1 1
 0 1 0 1
 0 1 0 0
 1 1 0 0
 1 1 0 1
 1 1 1 1
 1 1 1 0
 1 0 1 0
 1 0 1 1
 1 0 0 1
 1 0 0 0)

  +/'~0=':'+!4#2
0 1 2 1 2 3 2 1 2 3 4 3 2 3 2 1

  2<+/'~0=':'+!4#2
0 0 0 0 0 1 0 0 0 1 1 1 0 1 0 0

  &2<+/'~0=':'+!4#2
5 9 10 11 13

그리고 모두 함께 :

  {&2<+/'~0=':'+!x#2}'3 4 5 
(,5
 5 9 10 11 13
 5 9 10 11 13 17 18 19 20 21 22 23 25 26 27 29)

핍, 13 + 1 = 14 바이트

명령 행에서 입력을 받아서 -s출력 번호 사이의 공백에 플래그를 사용합니다 .

01NTB_FI,2**a

매우 간단합니다 : 빌드 range(2**a)하고 필터링하십시오 lambda _: "01" in toBinary(_). 나는 01아이디어를 독립적으로 생각하는 것에 매우 만족 했다. 01숫자 리터럴로 스캔하기 때문에 따옴표가 필요하지 않습니다 (숫자와 문자열은 Pip에서 동일한 유형 임).

줄리아, 40 바이트

n->filter(i->count_ones(i$i>>1)>2,1:2^n)

이것은 다른 Julia 솔루션에 대해 약간 다른 접근 방식을 사용합니다. 비트 문자열에서 "01"에 대한 문자열 검색을 수행하는 대신 일부 수학을 사용하여 숫자가 조건을 만족하는지 여부를 판별합니다.

i$i>>1숫자가 0에서 1로 바뀌거나 1에서 0으로 바뀌는 곳에만 있습니다. 따라서 i0 회에서 1 회 사이에서 앞뒤로 전환하려면 3 개 이상이 있어야합니다 . count_ones하나의 수를 찾은 다음 filter충분하지 않은 것을 제거합니다.

C ++, 197 188 141 바이트

참고 :이 작성하고이 나타납니다 MSVC ++ 2013를 사용하여 테스트 한 #includeING는 <iostream>이 일을하는 데 필요한 C 헤더를 모두 포함한다. 또한 코드가 더 이상 C ++이 아닌 것으로 보이지만 C ++를 사용하여 컴파일하면 C 헤더를 많이 포함하는 것보다 코드 크기를 줄이는 헤더 트릭이 허용됩니다.

printf대신에를 사용 cout하면 몇 바이트가 절약됩니다.

골프 :

#include<iostream>
int main(int a,char**b){char c[34];for(long i=5;i<1L<<atol(b[1]);++i){_ltoa(i,c,2);if(strstr(c,"01"))printf("%ld\n",i);}}

언 골프 드 :

#include <iostream>
int main(int a, char **b) {
  char c[34];
  for (long i = 5; i < 1L << atol(b[1]); ++i) {
    _ltoa(i, c, 2);
    if (strstr(c, "01"))
      printf("%ld\n", i);
  }
}

Perl 5, 55 53 49 47 41 바이트

sprintf("%b",$_)=~/01/&&say for 0..2**<>

54 52 48 46 40 바이트에 + -E대신 플래그에 1을 더한 값 -e.

대신 에 사용 에 대한 힌트 를 얻은 xnor 덕분에 2 바이트가 절약되었습니다./01//10+1/

을 (를) 대신 사용하여 6 바이트를 절약 한 Dennis 에게 감사 합니다.<>$ARGV[0]

C, 84 81 바이트

long i,j,k;main(){for(scanf("%ld",&j);++i<1L<<j;k&k+1&&printf("%ld ",i))k=i|i-1;}

이것은 간단한 비트 연산자 사용 가능성에 대한이 질문에 대한 다른 C 답변에 대한 의견을 기반으로합니다. 명령문 i | (i-1)에서 모든 후행 0 비트를 1로 전환하여 작동합니다. 그런 다음 k & (k + 1)을 사용하여 모든 후행 1 비트를 0으로 전환합니다. 한 번의 실행 만 있으면 0이되고, 그렇지 않으면 0이 아닙니다. long이 64 비트라고 가정하지만 대신 int64_t를 사용하여 3 바이트를 희생하여이를 수정할 수 있습니다.

언 골프

long i,j,k;
main()
{
    for(scanf("%ld",&j);++i<1L<<j;)
    {
        k=i|(i-1);
        if((k&(k+1)) == 0)
            printf("%d ",i);
    }
}

Pyth, 20 17 16 바이트

f:.BT"10+1"ZU^2Q

라이브 데모.

파이썬 2.7, 89 바이트

print[i for i in range(1,2**input())if[n[:1]for n in bin(i)[2:].split("0")].count("1")-1]

나는 이것이 약간 골프 될 수 있다고 생각합니다.

TI-BASIC, 34 32 30 바이트

TI-83 + / 84 + 시리즈 계산기 용.

For(X,5,e^(Ans
If log(sum(2=int(4fPart(X/2^randIntNoRep(1,Ans
Disp X
End

숫자에 2의 1을 포함 10하려면 이진 표현에 후행 0을 붙일 때 2를 포함해야합니다 .

이진 표현을 생성하고 a를 확인하는 대신 10나머지 4 ( int(4fPart() 를 사용하여 수학적으로 비트 쌍을 테스트 2합니다 10. 우리는 순서 상관하지 않기 때문에, randIntNoRep(는 IS 짧은 지수의 목록을 생성하는 방법.

우리 log(는 실행 횟수를 확인 하는 데 사용 합니다.

• 최소 2 회 실행이 log(있으면 양수가되고 숫자가 표시됩니다.

• 하나의 런이 있으면, log(는 0이며 숫자는 표시되지 않습니다.

• 런이없는 경우 (X = 2 ^ Ans에서 처음 발생) log(ERR : DOMAIN을 발생시켜 출력을 정확한 지점에서 중지합니다.

우리는 사용 e^(Ans의 종료 인자로 For(루프 항상 이상입니다 2^Ans,하지만 e^(그것은 한 바이트 짧은 그래서, 하나의 토큰입니다.

N = 4의 입력 / 출력 :

4:prgmRUNSONES
               5
               9
              10
              11
              13

그런 다음 계산기에 오류가 발생합니다. 오류 화면은 다음과 같습니다.

ERR:DOMAIN
1:Quit
2:Goto

1을 누르면 홈 화면이 다시 표시됩니다.

4:prgmRUNSONES
               5
               9
              10
              11
              13
           Error

TI 계산기는 정수 또는 이진 부동 소수점이 아닌 14 자리 정밀도로 BCD 부동 소수점에 모든 숫자를 저장합니다. 따라서 2의 거듭 제곱으로 나눈 값이 2^14정확하지 않을 수 있습니다. 내가 가장 까다로운 수 있다는 것을 확인 한 동안 3*2^30-1하고 2^32-1, 올바르게 처리, 나는 반올림 오류의 가능성을 배제하지 않고있다. 그러나 입력에 오류가 있으면 놀랐습니다.

• 이것은 flawr의 대답을 이길 수는 없지만 질문의 매력에 저항 할 수는 없었습니다.

MATLAB(90)(70)

j=input('');for l=2:j-1,a=1;for k=l:-1:2,a=a+2^k;a:a+2^(k-1)-2,end,end

실행

4

ans =

5

ans =

9    10    11

ans =

13

원리

• 일련의 숫자는 결과 1의 스트립 결과로 f (n, l) = 2 ^ l + 2 ^ (l + 1) + .... 2 ^ n을 의미합니다.

간격에서 얻은 숫자] f (n, l), f (n, l) + 2 ^ (l-1) [여기서 l> 1은이 조건을 확인하므로 결과는이 계열의 부정의 결과입니다. n의 조건.

x = 1

x = x + 1 = 01,

x = x + 2 ^ 0 = 11,

x = x + 1 = 001,

x = x + 2 ^ 1 = 011,

x = x + 2 ^ 0 = 111,

x = x + 1 = 0001,

x = x + 2 ^ 2 = 0011,

x = x + 2 ^ 1 = 0111,

x = x + 2 ^ 0 = 0111,

x = x + 1 = 1111...

x + 1, x = x + 2 ^ n, x = x + 2 ^ (n-1) ... x = x + 2 ^ 0

내 프로그램은 각 두 줄 사이의 범위를 인쇄합니다 (존재하는 경우)

편집 : 불행히도 골프를 더 많이 만들지는 않지만이 아이디어를 진행하는 또 다른 접근법을 추가하고 싶었습니다.

투쟁 후 나는이 시리즈의 수학적 표현을 찾기 위해 성공했다 :

l + k <n 인 2 ^ l (0 + 1 + 2 ^ 1 + ... 2 ^ k)

= 2 ^ l (2 ^ k-1)

점수 = 90

@(n)setdiff(0:2^n-1,arrayfun(@(x)2^mod(x,(n+1)-fix(x/(n+1)))*(2^fix(x/(n+1))-1),0:(n+1)^2))

C, 103102 바이트

long i,x;main(int a,char**b){for(;++i<1L<<atoi(b[1]);)for(x=i;x>4&&(x%4!=1||!printf("%ld,",i));x/=2);}

01이진 표현에서 패턴에 대한 xnor의 언급을 이용하지만 표준 함수와 약간의 비트 twiddling을 사용하여 G.Sliepen 항목에 대한 확장 (실제로 수축) .

언 골프 버전 :

long i, x;
main(int a, char**b) {
    for (; ++i < 1L << atoi(b[1]);) {
        for (x = i; x > 4 && (x % 4 != 1 || !printf("%ld,", i)); x /= 2)
            ;
    }
}

내부 루프 는 왼쪽에 3 비트가있는 한 반복적으로 오른쪽으로 이동 i하여 이진 패턴 01을 스캔 합니다 x. printf는 인쇄 된 문자 수를 반환하므로 never 0이므로 내부 루프 테스트 printf는 break문 다음에 실패 하여 문 이 필요하지 않습니다 .

C ++, 129128 바이트

동일한 아이디어를 적용하여 C ++ 변형은 다음과 같습니다.

#include<iostream>
long i,x;int main(int a,char**b){for(;++i<1L<<atoi(b[1]);)for(x=i;x>4&&(x%4!=1||!(std::cout<<i<<','));x/=2);}

기술적으로, 내가해야 i을 long long64 비트 연산을 보장하고 최대 개까지 계산하기 위해 2^32여분의 5 바이트지만, 현대 플랫폼은 64 개 비트의 int 있습니다.

자바 스크립트 ES6, 60 바이트

암호

n=>[...Array(1<<n).keys()].filter(g=x=>x>4?x%4==1|g(x>>1):0)

온라인으로 사용해보십시오!

설명

[...Array(1<<n).keys()]                                          Create an array of numbers from 0 to 2^n-1
                       .filter(                                  Find the numbers which meet criteria
                               g=x=>x>4?                  :0     If x is less than or equal to four return zero (false/invalid)
                                        x>4?x%4==1|              If the binary pattern ends with 01 return one (true/valid)
                                                   g(x>>1)       Otherwise bitshift right by one and try again

C (일종-GCC에서 경고와 함께 컴파일)-103

printf를 제외한 모든 종류의 라이브러리 함수를 사용하지 않습니다. 표준을 준수하거나 UB를 피하기 위해 아무런 노력도 기울이지 않았다는 것을 살펴보면 알 수 있습니다.

x,c;main(n,v){n--;for(;c<1<<n;c++)for(v=0;v<32;v++)if(c&1<<v){if(x&&x<v&&printf("%d ",c))break;x=v+1;}}

그것을 준수하기 위해서는 stdio.h를 포함하여 가능한 한 작게 만드는 정신에 위배되는 많은 일을해야합니다.

누구든지 짧게 만들 제안이 있으면 알려주십시오.

PowerShell, 80 바이트

while([Math]::Pow(2,$args[0])-gt$n++){$n|?{[Convert]::ToString($n,2)-match"01"}}

파이썬, 44 바이트

좋아, 아마도 더 짧을 수도 있지만 내 첫 번째 코드 골프입니다.

x=1
while True:
    if '01' in bin(x):
        print(x)
    x+=1

이 질문에 대한 답변이라고 생각하십시오. 그렇지 않은 경우 투표하지 말고 아래에 문제를 게시하십시오.

좋은 점수의 또 다른 matlab 답변.

MATLAB 60(57)

@(n)find(mod(log2(bitcmp(1:2^n,fix(log2(1:2^n)+1))+1),1))

실행

>> @(n)find(mod(log2(bitcmp(1:2^n,fix(log2(1:2^n)+1))+1),1))

ans =

@(n)find(mod(log2(bitcmp(1:2^n,fix(log2(1:2^n)+1))+1),1))

>> ans(5)

ans =

 5     9    10    11    13    17    18    19    20    21    22    23    25    26    27    29

• 아이디어 는-(x) +1의 이진 표현에 단 하나의 발생 만 포함하지 않는 숫자 x를 선택합니다.1

예:

0000111~ x = 1111, ~ x + 1 = 00001에 하나의 숫자가 포함되어 있기 때문에 거부됩니다.

0100111~ x = 1011, ~ x + 1 = 0111은 많은 1을 포함 하므로 허용됩니다.