회전 안전 번호 인쇄


29

배경

일부 보드 게임 제조업체에서 일하고 있으며 일부 게임의 경우 0에서 n 까지 숫자가 새겨진 나무 타일을 생산해야합니다 . 그러나 더 이상 고민하지 않으면 일부 타일은 구분할 수 없게됩니다 (예 : 6및) 9. 이를 방지하려면, 당신은 명확하게하는 점, 예를 들면와 (과 만) 다른 사람과 혼동 할 수있는 숫자를 장착해야합니다, 당신은 같은 타일 것 9.또는 6089..

불행히도, 인터페이스가 너무 깨져서 말할 것도없이 지루한 프로세스로 프로그램의 모든 문자를 인코딩 해야하는 구식이지만 프로그래밍 가능한 오래된 나무 조각 장치를 사용해야합니다. 다행히도 장치는 기존의 모든 프로그래밍 언어를 이해합니다. 따라서 이러한 타일을 인쇄하는 가장 짧은 프로그램을 찾고 있습니다.

실제 작업

가장 짧은 프로그램을 작성하십시오.

  • 양의 정수 n 을 입력으로 사용합니다. 입력을 읽는 방법은 귀하에게 달려 있습니다.
  • 단일 공백 ​​문자 (개행 문자 포함)로 구분하여 선택한 순서대로 0에서 n (0 및 n 포함)의 각 숫자를 정확히 한 번만 인쇄합니다 . 숫자는 선행 0없이 인쇄됩니다.
  • 숫자가 n 보다 큰 경우에도 π (180 °) 회전 할 때 유효한 다른 숫자로 바뀌는 모든 숫자에 점 (.)을 추가합니다 . 서체의 0과 8은 회전 대칭이며 9는 회전 6입니다. 2와 5는 회전시 서로 다릅니다. 1은 회전 대칭이 아닙니다. 앞에 0이있는 숫자는 유효하지 않습니다.

다음과 같은 각 번호는이 방법으로 정확하게 인쇄해야합니다.

  • 2
  • 4
  • 5
  • 6.
  • 8
  • 9.
  • 16
  • 60
  • 66.
  • 68.
  • 69
  • 906
  • 909.
  • 8088.
  • 9806.
  • 9886
  • 9889.

는 안 6060.?
red-X

2
@ red-X "앞에 0이있는 숫자는 유효하지 않습니다."
Sp3000

2
@rationalis : 이것에 대한 표준 허점 이 있습니다. (또한 해당 기계에 해당 언어를 가르쳐야하기 때문에 주제별로 의미가 없습니다.) 어느 쪽이든 기존
Wrzlprmft

2
@rationalis 일반적으로 발생하는 일은 챌린지 게시 이전에 존재하는 언어 버전 만 우승 프로그램이 될 수 있다는 것입니다. 이후의 버전은 여전히 ​​재미있게 게시 할 수 있지만 게시되지 않은 게시물을 지정해야합니다. 예 , 그러한 언어를 정의 할 수는 있지만 표준 허점으로 인해 부적합하고 잘 받아들이지 않을 것입니다 (위와 같이).
Sp3000

3
나는 8088.당신의 예제에 6 또는 9가없는 안전하지 않은 회전 숫자로 포함시키는 것이 도움이 될 것이라고 생각합니다.
El'endia Starman

답변:


6

피스 -34 38

VhQJ`N+J*\.&nJX_J`69`96&eN!-J"0689

4 바이트를 제거하는 데 도움을 주신 @ Sp3000에 감사해야합니다. 나는 원래 수 &@JK에 6 또는 9가 있는지 확인하는 추가 검사 를 받았지만 게시하기 전에 답변을 읽은 후에 그의 답변을 읽었으며 동일한 번역 및 반전이 이미 처리되었음을 알았습니다.

또한 문자열이 반복 가능하다는 점을 지적 한 @isaacg 덕분에 세트 작업을 사용할 수 있습니다. 또한 현재 코드를 만들기 위해;)

설명:

                                    : (implicit) Q=eval(input())
VhQ                                 : for N in range(Q+1):
   J`N                              : J=str(N)
      +J*\.                         : J + "." * ...
           &nJX_J`69`96             : J!=translate(reversed(J),"69","96") and...
                       &eN          : N%10 and...
                          !-J"0689  : not(setwise_difference(J, "0689"))

나는 당신을 위해 정수의 목록을 사용할 필요가 있다고 생각하지 않습니다 KJ대신 사용하는 문자열을 -. 전환 K에 <역 따옴표> 69 J에 <역 따옴표> N이 같은 인라인 않는, 몇 문자를 저장 K결과 프로그램. 그 기술을 얻을 수있는 가장 짧은 시간은 VhQJ``N+J*\.&nJX_J``69``96&eN!-J"068934 자였습니다. (두 역 따옴표는 정말 하나입니다.)
isaacg

@isaacg 팁 주셔서 감사합니다! 나는 어떤 이유로 문자열을 만드는 것이 실제로 pyth에서 짧다는 것을 잊어 버렸다고 생각합니다. 어쨌든 \로 이스케이프 처리하여 백틱으로 코드 블록을 작성할 수 있습니다. 예를 들면 :hell`o wo`rld
FryAmTheEggman

설명에서 _, 앞에 추가가있는 것 같습니다 `96.
isaacg 2014

@isaacg 감사합니다, 고정
FryAmTheEggman

10

CJam, 46 44 43 42 바이트

l~),{_A%g1$s_6890s-!\_69s_W%erW%=!&&'.*N}/

개선의 여지가 있다고 생각합니다.

여기에서 테스트하십시오.

설명

l~),{_A%g1$s_6890s-!\_69s_W%erW%=!&&'.*N}/
l~                                         "Read an eval input.";
  ),                                       "Get range from 0 to n.";
    {                                   }/ "For each...";
     _                                     "Get a copy of the integer.";
      A%g                                  "Ends with digit other than 0?";
         1$s_                              "Get another copy, convert to string, get a copy.";
             0689s-!                       "Contains rotation-safe digits?";
                    \                      "Swap with other copy.";
                     _                     "Get another copy.";
                      69s_W%er             "Swap 6 and 9.";
                              W%           "Reverse.";
                                =!         "Is different from original?";
                                  &&       "AND all three conditions.";
                                    '.*    "If true, push a period (else, an empty string).";
                                       N   "Push a newline.";

입력이 8 일 때이 값은 무엇을 반환합니까? (입력에 코드를 붙여 넣은 다음 실행 버튼을 클릭했지만 오류가 발생했습니다.)
DavidC

@DavidCarraher는 코드를 "Code"와 nInput 에 넣습니다 .
Martin Ender

입력 98에서 프로그램은 66 옆에 점을 표시합니다.
Sparr

3
@Sparr 답변이 유효하지 않다고 말하기 전에 OP가 질문에 답변 할 때까지 기다려야합니다. 그의 진술 : "다음 숫자 각각은 정확히 이런 식으로 인쇄되어야합니다"는 해석과 모순되는 것 같습니다.
FryAmTheEggman

나는 CJam 설명의 아름다움을 좋아한다.
nyuszika7 시간


5

APL 66

∊' ',¨{a←⌽'0.....9.86'[⎕D⍳b←⍕⍵]⋄'.'∊a:b⋄('0'=⊃a)∨⍵=⍎a:b⋄b,'.'}¨0,⍳

설명:

¨0,⍳           applies the function to each number 0-n
a←⌽'0.....9.86'[⎕D⍳b←⍕⍵] inverts 6s and 9s, leaving 8s and 0s, and replacing other numbers with dots. Reverses vector after substitution.
'.'∊a          if there is a dot in the number....
('0'=⊃a)       .. or if the number starts with 0...
⍵=⍎a           or if the (inverted) number is the same as original
:b             then print the original number
b,'.'          else print a dot in the end
∊' ',¨        Finally to give the result in the asked format i add a single space after each result and join them all 

tryapl.org에서 사용해보십시오

온라인 인터프리터에서 ⍎ 함수가 작동하지 않으므로이 경우 동일한 기능을 수행하는 2⊃⎕VFI로 대체해야하고 문자열이 주어진 경우 숫자를 실행하고 반환합니다.


60, 69, 90 및 96에는 점이 없어야합니다.
ngn

감사합니다 @ ngn, 수정했습니다. 지금 제대로 작동한다고 생각합니다.
Moris Zucca

2
잘했습니다 :) 대신 ⊃,/또는 앞에서를 ,/사용할 수 있습니다 .
ngn

아 맞다! 나는 보통 ml1에서 작동하지 않으므로 ∊에 대해 잊어 버립니다.
Moris Zucca

4

펄 5, 53 바이트

say$_,"."x(!/[1-57]|0$/&&reverse!=y/96/69/r)for 0..<>

온라인 데모.

Perl 5.10+ say기능을 사용하므로이 기능을 사용하려면 perl -M5.010(또는 perl -E)로 실행해야합니다. ( 이 메타 스레드를 참조하십시오 . ) stdin에서 입력을 읽고 stdout으로 인쇄합니다.


4

파이썬 2 130 116 113 바이트

def f(n):S=`n`;n and f(n-1);print S+"."*all([n%10,set(S)<=set("0689"),(u""+S[::-1]).translate({54:57,57:54})!=S])

f숫자를 STDOUT에 오름차순으로 인쇄 하는 함수 를 정의합니다 .

이번에는 @feersum의 책에서 잎을 가져갈 것이라고 생각했습니다. .translate:)

넓히는:

def f(n):
 S=`n`        
 n and f(n-1)                                      # Recurse if not 0                                     
 print S+"."*all([n%10,                            # Not divisible by 10
                  set(S)<=set("0689"),             # Consists of 0689
                  (u""+S[::-1]).translate
                  ({54:57,57:54})!=S])             # When rotated is not itself

이전 솔루션 :

def f(n):S=`n`;print S+"."*all([n%10,set(S)<=set("0689"),eval("S[::-1]"+".replace('%s','%s')"*3%tuple("6a96a9"))!=S]);n and f(n-1)

.replace얼마 전에 트릭 을 보여준 @xnor에게 감사드립니다 .


(u''+S[::-1])대신 사용할 수 있습니다 unicode(S[::-1]). print또한와 재귀 통화 를 교환하면 번호가 오름차순으로 나옵니다.
ngn

@ngn 아 감사합니다, 나는 u""+실제로 작동 하지 않을 것이라고 생각 했다
Sp3000

나는 이것이 더 작아야한다고 생각한다. 예를 들어, "p"라고 말하는 것이 아니라 인쇄가 올바르게 인쇄되었다는 것은 당신의 잘못이 아니라 "p = print"를 쓰고 "공식"제출에서 바이트로 계산하지 않았다면 그것을 단축했다!
Alec Teal

4

C #, 343 309 자

방법 너무 긴하지만, 어쨌든 :

namespace System.Linq{class C{static void Main(){int n=int.Parse(Console.ReadLine());for(int i=0;i<=n;i++){var b=i+"";var c=b.Replace("6","9");Console.Write(b+(b.All(x=>x=='0'|x=='8'|x=='6'|x=='9')&!b.EndsWith("0")&!(b.Count(x=>x=='6')==b.Count(x=>x=='9')&new String(c.Reverse().ToArray())==c)?". ":" "));}}}}

어떻게 작동합니까? 숫자에 마침표를 추가하려면 다음 요구 사항과 일치해야합니다.

  • 단지로 구성 0, 8, 69.
  • 0으로 끝나지 않습니다.
  • 회전 할 때 같은 숫자가 아닙니다 :
    • 숫자가 6s와 9s의 양이 같은 경우
    • 경우 c= 모든과 수가 6로 대체합니다을이야 9의,
    • 반대로 c== c,
    • 회전 된 숫자는 숫자 자체와 동일합니다.

숫자는 공백으로 구분됩니다.

들여 쓰기 코드 :

namespace System.Linq
{
    class C
    {
        static void Main()
        {
            int n = int.Parse(Console.ReadLine());
            for (int i = 0; i <= n; i++)
            {
                var b = i + "";
                var c = b.Replace("6", "9");
                Console.Write(b +
                    (b.All(x => x == '0' | x == '8' | x == '6' | x == '9') &
                    !b.EndsWith("0") &
                    !(b.Count(x => x == '6') == b.Count(x => x == '9') &
                    new String(c.Reverse().ToArray()) == c) ? ". " : " "));
            }
        }
    }
}

1
내 대답 은 더 길다;) 골프 코스에서 볼링을하는 것으로 보입니다.
Digital Trauma

1
8808은 어떻습니까? 6 또는 9는 없지만 회전하면 8088입니다.
El'endia Starman

1
@ El'endiaStarman 감사합니다! 제출물을 수정하는 동안 실제로 문자를 저장했습니다. :)
ProgramFOX

4

남 (MUMPS) -72 70

R n F i=0:1:n W !,i S r=$TR($RE(i),69,96) W:r=+r*r'=i*'$TR(i,0689) "."

M의 대부분의 내장 명령 및 기능에는 약어 버전이 있습니다. 아래의 전체 이름을 사용했습니다.

READ n-키보드에서 문자열을 읽고 저장하십시오 n.

FOR i=0:1:n- 매번 1 n씩 증가 i하여 0에서로 반복 합니다. (라인의 나머지 부분은 루프의 본문을 구성합니다.)

WRITE !,i -줄 바꿈과 값을 인쇄하십시오. i .

SET r=$TRANSLATE($REVERSE(i),69,96))-반대로 i, 9를 6으로 바꾸고 6을 9로 바꾸고 그 안에 저장하십시오 r.

WRITE:r=+r*r'=i*'$TRANSLATE(i,0689) "."

  • :-사후 조건식을 나타내므로 WRITE명령은 다음과 같은 경우에만 실행됩니다r=+r*r'=i*'$TRANSLATE(i,0689) 정확한 값으로 평가 .
  • r=+r- r앞에 0이 없는지 확인하십시오 . 단항+ 연산자는 문자열을 숫자로 변환하며 앞에 0이 있으면 제거합니다.
  • *-곱셈 연산자. M은 작업 순서가 없습니다. 모든 이진 연산자는 왼쪽에서 오른쪽으로 나타나는 순서대로 평가됩니다.
  • r'=i- i뒤집힌 버전과 동일하지 않은지 확인r .
  • '$TRANSLATE(i,0689)-에서 0, 6, 8 및 9를 모두 제거하고 i남은 것이 없는지 확인합니다. ( '논리 부정 연산자입니다.)
  • "."-마지막으로 WRITE명령에 대한 인수 (리터럴 문자열).

편집 : 곱셈 연산자를 남용하여 조금 짧게 만들었습니다. 이전 버전:

R n F i=0:1:n W !,i S r=$TR($RE(i),69,96) I '$TR(i,0689),i'=r,r=+r W "."

3

APL, 53 자

∊{⍵,'. '↓⍨∨/(3≡⊃i)(5∊i),⍵≡'9608x'[i←⌽'6908'⍳⍵]}∘⍕¨0,⍳

0,⍳N        numbers 0..N
{...}∘⍕¨    format each number as a string and do the thing in curly braces
                inside the braces ⍵ is the current string
'6908'⍳⍵    encode '6' as 1, '9' as 2, '0' as 3, '8' as 4, and all others as 5
⌽           reverse
'9608x'[A]  use each element of A as an index in '9608x':
                effectively: swap '9'←→'6', preserve '08', mask other digits
⍵≡          does it match the original string?
                this is the first boolean condition, two more to come
5∊i         did we have a digit other than '0689'?
3≡⊃i        is the first of i (that is, the last of ⍵) a '0' (encoded as 3)?
∨/          disjunction ("or") over the three conditions, returns 0 or 1
'. '↓⍨      drop 0 or 1 elements from the beginning of the string '. '
⍵,          prepend ⍵
∊           flatten the results to obtain a single output string

3

C # 205209

C #은 그리 길지 않아도됩니다 ...
약간의 JavaScript 답변 포트

class P{static void Main(string[]a){for(int n=int.Parse(a[0]);n>=0;--n){string p="",u=n+p;int e=n%10;foreach(var d in u)p=(d<56?d!=54?d>48?e=0:0:9:120-d-d)+p;System.Console.WriteLine(e!=0&p!=u?u+".":u);}}}

언 골프

class P 
{
    static void Main(string[] a)
    {
        for (int n = int.Parse(a[0]); n >= 0; --n)
        {
            string p = "", u = n + p;
            int e = n % 10;
            foreach (var d in u) p = (d < 56 ? d != 54 ? d > 48 ? e = 0 : 0 : 9 : 120 - d - d) + p;
            System.Console.WriteLine(e != 0 & p != u ? u + "." : u);
        }
    }
}

2

루비, 81

?0.upto(*$*){|x|puts x.reverse.tr('69','96')!=x&&x=~/^[0689]+$/&&/0$/!~x ?x+?.:x}

입력은 명령 행에서 가져옵니다.

String에서 0까지 의 목록을 생성합니다 n. 그것들을 통과시켜 인쇄합니다. 모든 조건이 충족되면 점을 추가합니다.

  • 숫자를 반대로 바꾸고 6s를 9s로 바꾸면 원본이 나오지 않습니다.
  • 숫자는 숫자로 구성 0, 6,89
  • 숫자는 끝나지 않습니다 0

2

자바 스크립트 (ES6) 101 104 106 109

CONSOLE.LOG 통해 인수 출력 된 N과 함수
편집 0 유도하기위한 시험의 10 %를 사용하여
편집 2 for 모두 이후에 재구성, I 배열 이해를하지 않아도
편집 3 0을 유도하기위한 (다시) 체크 수정

F=n=>{
   for(;e=~n;console.log(e*l&&p-n?n+'.':n),--n)
     for(d of(p='')+n)p=(l=d<8?d-6?-d?e=0:0:9:24-d-d)+p
}

확고 하고 테스트하기 쉬운

F=n=>
{
  o = '';
  for( ; ~n; --n) // loop on n decreasing to 0 (~n is 0 when n==-1)
  {
    e = ~n; // init to a nonzero value, zero will mark 'invalid digit'
    p = ''; // build rotated number in p
    for(d of '' + n)
    {
      // l is the current digit, on exit will be the first digit of p
      l = d < 8 ?
            d != 6 ?
              d != 0 ?
                e = 0 // invalid char found, no matter what
                : 0 
              : 9 // 6 become 9
            : 24 - d - d; // calc 8 => 8, 9 => 6
      p = l + p;
    }       
    // e==0 if invalid char, l==0 if leading 0
    o += ' ' + ( e * l && p-n ? n+'.' : n);
  }
  console.log(o);
}

F(100)

산출

100 99. 98. 97 96 95 94 93 92 91 90 89. 88 87 86. 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68. 67 66. 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9. 8 7 6. 5 4 3 2 1 0

대괄호 안에 for 루프가있는 구성의 이름이 []있습니까? 나는 지금까지 파이썬에서만 이것을 알고 있었기 때문에 문서를 찾고 있습니다.
flawr

1
줄 바꿈을 많이 절약 할 수 있다고 생각합니다.
britishtea

1
@britishtea 개행 및 들여 쓰기는 가독성을 위해 추가되었지만 계산되지 않았습니다. 이 한 줄의
edc65


1

배쉬 + coreutils, 105

for((i=0;i<=$1;i++));{
[ ${i//[0689]/} ]||[ $i = `rev<<<$i|tr 69 96` ]||((!${i: -1}))||d=.
echo $i$d
d=
}

테스트:

$ ./rotproof.sh 100 | grep "\."
6.
9.
66.
68.
86.
89.
98.
99.
$ 

1

sed, 467

C #보다 길다 ...

@ edc65가 대답이 n이 아니라 숫자 0-n을 처리해야한다고 지적했을 때 이것을 거의 완성했습니다. 0-n을 증가시키기 위해 sed 코드를 추가하면이 작업이 산술적 sed에 적합하지 않기 때문에 많은 코드가 추가됩니다.

:l
/^[0689]*$/{
h
s/$/:/
:x
s/([0-9]):(.*)/:\2\1/
tx
s/://
y/69/96/
G
/^([0-9]+)\n\1/be
s/^[^0].*/&./
:e
s/.*\n//
}
p
s/\.//
s/[0-9]/<&/g
s/0//g;s/1/_/g;s/2/__/g;s/3/___/g;s/4/____/g;s/5/_____/g
s/6/______/g;s/7/_______/g;s/8/________/g;s/9/_________/g
:t
s/_</<__________/
tt
s/<//g
s/_//
:b
s/__________/</g
s/<([0-9]*)$/<0\1/
s/_________/9/;s/________/8/;s/_______/7/;s/______/6/
s/_____/5/;s/____/4/;s/___/3/;s/__/2/;s/_/1/
s/</_/g
tb
s/^$/0/
/^0$/by
bl
:y
c\
0
p

OP에 따라 순서는 중요하지 않으므로 n에서 0으로 하향 조정됩니다.

산출:

$ sed -rnf rotproof.sed <<< 100 | grep "\."
99.
98.
89.
86.
68.
66.
9.
6.
$ 

1

AWK : 120

{a[a[6]=9]=6;a[8]=8;for(j=a[0]=0;j<=$0;++j){r="";for(i=j;i;i=int(i/10))r=r a[i%10];print(j~/[^0689]|0$/||j==r)?j:j"."}}

stdin에서 n 값을 읽습니다.

테스트:

C : \ AWK> gawk -f revnum.awk | grep \.
100
^ Z
6.
9.
66.
68.
86.
89.
98.
99.


1

리볼-195

for n 0 do input 1[b: copy a: form n d: c: 0 parse reverse a[any[m:"6"(change m"9"++ c)|"9"(change m"6"++ c)|"0"|"8"| skip(++ d)]]print rejoin [b either all[d = 0 c > 0 a != b a/1 != #"0"]"."{}]]

Ungolfed + 일부 주석 :

for n 0 do input 1 [
    b: copy a: form n
    d: c: 0

    ; reverse number and rotate "6" & "9"
    ; and do some counts (c when "6" or "9" and d when != "0689")
    parse reverse a [
        any [
            m:
              "6" (change m "9" ++ c)
            | "9" (change m "6" ++ c)
            | "0"
            | "8"
            | skip (++ d)
        ]
    ]

    print rejoin [
        b either all [
            d = 0               ; only has 0689 digits
            c > 0               ; must have at least one "6" or "9"
            a != b              ; not same when reversed
            a/1 != #"0"         ; does not "end" with zero
        ]
        "." {}                  ; if ALL then print "." else blank {}
    ]
]

1

기원전 158

네이티브 산술없이 모든 문자열 및 정규식 작업을 사용하여 sed에서 순수 하게이 작업을 수행 한 후 이것이 다른 방식으로 어떻게 보일지 궁금합니다. 즉 모든 산술 및 논리 연산과 문자열 / 정규 표현식이 없습니다.

for(i=read();i+1;r=0){p=1
for(x=i;x;x/=A){d=x%A
if(x==i&&!d)p=0
if(d==6||d==9)d=F-d else if(d%8)p=0
r=r*A+d}
if(r==i)p=0
print i--
if(p)print "."
print "\n"}

출력은 내림차순으로 정렬됩니다.

산출:

$ bc rotproof.bc <<< 100 | grep "\."
99.
98.
89.
86.
68.
66.
9.
6.
$ 

1

파이썬-152

for i in range(input()+1):print`i`+("."*all([j in"0689"for j in`i`])and`i`[-1]!="0"and`i`!=`i`.replace("9","x").replace("6","9").replace("x","6")[::-1])

+1. 좋아 보인다 ... 더 짧아지기위한 몇 가지 트릭을 배우고 싶다면 python 2에는 replace 대신 translate를 사용하는 또 다른 대답이 있으며 편집 기록에는 3 개의 replace를 1로 결합하는 방법도 있습니다. 미래의 질문에 편리하게 ...
trichoplax

2
좋은 진행입니다! 위의 골프 이외에도 더 많은 골프가 있습니다 : "."if a[i]else"" -> "."*a[i], int(raw_input()) -> input()(실제로 eval(raw_input()))
Sp3000

일부 golfes : (1) 파이썬 2에서, 당신은 대체 할 수 str(i)와 함께 `i`. (2) a한 번만 사용 하므로 변수에 할당하는 이유는 무엇입니까?
Wrzlprmft 2019 년

두 번째 제안을 사용하지만 str(i)여러 번 사용 합니다. 어느 것으로 교체 할 수 i있습니까?
KSFT

1
하지 ii에 동의어 역 따옴표와 repr(i). 여러 번 사용하는 경우 변수에 할당하고 백틱을 사용하는 것 외에도 사용하는 것이 더 짧을 수 str(i)있지만 어디서나 사용할 수 있습니다 str(i). (예 x=`i`; (do stuff with x))
SP3000

1

자바 스크립트 - 168 129 119 113 111 108

F=n=>{for(;~n;n--){r='';for(c of""+n)r=(c-6?c-9?c:6:9)+r;console.log(r-n&&!/[1-57]/.test(r)&&n%10?n+".":n)}}

4 5 6. 8 9. 16 60 66. 68. 69 906 909. 6090 9806. 9886 9889.

또는 읽을 수있는 버전 :

F=n=>{for(;~n;n--){
    r='';for(c of ""+n)r=(c-6?c-9?c:6:9)+r; // rotate
    console.log( // output, new-line is added
        // original number, and
        // append dot only if number is different than its rotated version and no un-rotatable digit is present and there is no zero at the end
        r-n && !/[1-57]/.test(r) && n%10
           ?n+".":n
    )}}

나는 정규식, 어떤 아이디어에 만족하지 않습니까?

편집 :와 깔끔한 트릭을 습득 ~하고 for (... of ...)@ edc65에서
Edit2가 개편 조건 :
EDIT3이 :에 의해 제안을 적용 @ edc65


나쁜 눈동자 :) i=n+"";for(c of i)=> for(c of i=n+"")2 바이트 저장
edc65

... and c==6?A:B=> c!=6=>B:A=>c-6?B:A
edc65

또한 일반적으로 1 바이트 더 짧은 String.match (Regexp) 대신 Regexp.test (String)를 사용할 수 있습니다.
edc65

6 바이트는 총계입니다. 감사합니다 :) for(c of i=n+"")볼 때 상당히 논리적이지만 생각하지 않습니다. c-6?B:A신은 내가 이것을 프로덕션 코드에 넣지 말라고 금지했다
zabalajka

regexp에 대한 아이디어 : 1 광석이 아닌 1 개의 유효하지 않은 문자를 확인해야하므로 '+'가 필요하지 않습니다 .console.log 식으로 바이올린을 사용하면 8 바이트를 절약 할 수 있지만 대답은 너무 짧을 것입니다
edc65

1

05AB1E , 38 37 30 29 바이트

ÝεÐSUT%ĀiŽR!XåPiÐ69‡RÊi'.«]»

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

설명:

Ý                # Inclusive 0-based range: [0, (implicit) input]
 ε               # Map each integer to:
  Ð              #  Triplicate the current integer
  SU             #  Convert it to a list of digits, and pop and store it in variable `X`
    Ti         #  If the current integer contains no trailing zeros
    ŽR!XåPi      #  And if the current integer only consists of the digits [0689]
    Ð69‡RÊi     #  And if the current integer is not the same when its 6s and 9s
                 #  are swapped and then the total is reversed
             '.« #   Concat a '.'
                 #  Implicit else: use the top of the stack (the duplicate current integer)
]                # Close all three ifs and the map
 »               # Join the resulting list by newlines (and output implicitly)

일부 부품에 대한 추가 설명 :

Ti       # Check if the integer contains no trailing zeros:
T          #  Push 10 (T is a builtin for 10)
 %         #  Modulo
  Ā        #  Trutified: 0 remains 0 (falsey), everything else becomes 1 (truthy)
           #   i.e. 12 % 10 → 2 → 1 (truthy)
           #   i.e. 68 % 10 → 8 → 1 (truthy)
           #   i.e. 70 % 10 → 0 → 0 (falsey) (70 remains as is)
           #   i.e. 609 % 10 → 9 → 1 (truthy)
           #   i.e. 808 % 10 → 8 → 1 (truthy)

ŽR!XåPi    # Check if the integer only consists of the digits 0, 6, 8 and/or 9:
ŽR!        #  Push 6890 (Ž is a builtin for 2-char compressed integers, where R! is 6890)
   X       #  Push variable `X` (the list of digits)
    å      #  Check for each of these digits if they're in "6890"
     P     #  Take the product of that list
           #   i.e. [1,2] → [0,0] → 0 (falsey) (12 remains as is)
           #   i.e. [6,8] → [1,1] → 1 (truthy)
           #   i.e. [6,0,9] → [1,1,1] → 1 (truthy)
           #   i.e. [8,0,8] → [1,1,1] → 1 (truthy)

Ð69‡RÊi   # Check if the integer with 6s and 9s swapped and then reversed isn't unchanged:
Ð          #  Triplicate the integer
 69        #  Push 69
   Â       #  Bifurcate (short for Duplicate & Reverse)
          #  Transliterate (in `a` replace all characters `b` with characters `c`)
     R     #  Reverse
      Ê    #  Check for inequality
           #   i.e. 68 → "68" → "98" → "89" → 68 != "89" → 1 (truthy) (68 becomes "68.")
           #   i.e. 609 → "609" → "906" → "609" → 609 != "609" → 0 (falsey) (609 remains as is)
           #   i.e. 808 → "808" → "808" → "808" → 808 != "808" → 0 (falsey) (808 remains as is)

0

펄-84

for(0..$ARGV[0]){s/6/x/g;s/9/6/g;s/x/9/g;printf"$_%s\n",$_=~/^[0689]+[689]$/?".":""}

0

파워 쉘, 111 102 바이트

param($s)$s+'.'*!($s-match'[1-57]|0$|'+-join$(switch -r($s[($s.Length-1)..0]){'0|8'{$_}'6'{9}'9'{6}}))

설명 된 테스트 스크립트 :

$f = {

param($s)           # input string
$l=$s.Length        # length of the string
$c=$s[($l-1)..0]    # chars of the string in the reversed order
$d=switch -r($c){   # do switch with regex cases for each char
    '0|8'{$_}       # returns the current char if it equal to 8 or 0
    '6'{9}          # returns 9 if the current char is 6
    '9'{6}          # returns 6 if the current char is 9
}                   # returns array of new chars (contains 0,6,8,9 only)
$s+'.'*!(            # returns s. Add '.' if not...
    $s-match'[1-57]|0$|'+-join$d
                    # $s contains chars 1,2,3,4,5,7 or
                    # ends with 0 or
                    # equal to string of $d
)

}

@(
    ,('2'    ,'2'   )
    ,('4'    ,'4'   )
    ,('5'    ,'5'   )
    ,('6.'   ,'6'   )
    ,('7'    ,'7'   )
    ,('9.'   ,'9'   )
    ,('16'   ,'16'  )
    ,('60'   ,'60'  )
    ,('66.'  ,'66'  )
    ,('68.'  ,'68'  )
    ,('69'   ,'69'  )
    ,('906'  ,'906' )
    ,('909.' ,'909' )
    ,('8088.','8088')
    ,('9806.','9806')
    ,('9886' ,'9886')
    ,('9889.','9889')
) | % {
    $e,$s = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

산출:

True: 2
True: 4
True: 5
True: 6.
True: 7
True: 9.
True: 16
True: 60
True: 66.
True: 68.
True: 69
True: 906
True: 909.
True: 8088.
True: 9806.
True: 9886
True: 9889.

0

Stax , 27 바이트

Ç▒≈♣▌╬"÷╜─B↓«âpø←╚S☼ì>♫è;&╛

실행 및 디버깅

포장을 풀고 포장을 풀고 주석을 달았습니다.

0p      print 0 with no line break
F       for each [1 .. n] execute the rest of the program, where n is the input
  zP    print a newline
  q     peek and print the iterating variable without newline
  A%!C  modulo 10, and cancel iteration if zero (this cancels for multiples of 10)
  _$cc  convert iterating value to string and duplicate it twice on the stack
  7R6-$ construct the string "123457"
  |&C   if the character intersection is truthy, cancel the iteration
  r     reverse string
  69$:t map 6 and 9 characters to each other
  =C    if this rotated string is equal to the original, cancel iteration
        print "." with no newline 
        (this comment precedes the instruction because it's an unterminated literal)
  ".

이것을 실행

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.