우리는 인생의 어느 시점에서 0으로 나누는 것이 불가능하다는 말을 들었습니다. 그리고 대부분의 경우, 그 진술은 사실입니다. 그러나 금지 된 작업을 수행 할 수있는 방법 이 있다면 어떨까요? 내 최신 작품에 오신 것을 환영합니다 : b-numbers.
b-숫자는 상상의 숫자와 조금 비슷합니다 : 관련된 주 계수는 수학적으로 불가능하지 않은 표현을 i나타냅니다 ( √를 나타냄)
). 이 경우
는 식 1 을 나타냅니다.
. 여기에서x가무엇인지 쉽게 판단 할 수 있습니다.
은 다음과 같습니다.
작업
0으로 나누는식이 주어지면
단순화 된 값을 출력합니다 . 입력은 n/0n이 임의의 유리수이거나 b10 진수 형식의-숫자 형식입니다. 선행 0과 후행 0은 포함되지 않습니다.
입력 예
4/0
1/0
0/0
80/0
-8/0
1.5/0
2.03/0
-1/0
-3.14/0
b/0
3b/0
-b/0
121/0
출력 예
4b
b
0
80b
-8b
1.5b
2.03b
-b
-3.14b
b
3b
-b
121b
점수
이것은 코드 골프이므로 가장 적은 바이트가 이깁니다. 표준 허점은 금지되어 있습니다.
리더 보드
다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.
답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.
# Language Name, N bytes
N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :
# Ruby, <s>104</s> <s>101</s> 96 bytes
헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .
# Perl, 43 + 2 (-p flag) = 45 bytes
언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
답변
Malbolge Unshackled (20 트릿 회전 변형), 3,62e6 바이트
이 답변의 크기가 게시 가능한 최대 프로그램 크기 (eh)를 초과하므로 코드가 내 GitHub 리포지토리에 있습니다 (참고 : CTRL + A 및 CTRL + C를 사용하여 코드를 복사하지 마십시오. 마우스 오른쪽 버튼을 클릭하고 “대상 요소를 다른 이름으로 저장”을 클릭하십시오. .. “).
이것을 실행하는 방법?
순진한 Haskell 통역사가 이것을 실행하기 위해 나이가 들기 때문에 이것은 까다로운 부분 일 수 있습니다. TIO는 괜찮은 Malbogle Unshackled 통역사가 있지만 슬프게도 사용할 수 없습니다 (제한 사항).
내가 찾을 수있는 가장 좋은 방법은 고정밀 20 회전 회전 폭 변형입니다.이 변형은 매우 잘 수행되며 즉시 계산합니다 .
인터프리터를 좀 더 빠르게 만들기 위해 Matthias Lutter의 Malbolge Unshackled 인터프리터에서 모든 검사를 제거했습니다.
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
"OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";
typedef struct Word {
unsigned int area;
unsigned int high;
unsigned int low;
} Word;
void word2string(Word w, char* s, int min_length) {
if (!s) return;
if (min_length < 1) min_length = 1;
if (min_length > 20) min_length = 20;
s[0] = (w.area%3) + '0';
s[1] = 't';
char tmp[20];
int i;
for (i=0;i<10;i++) {
tmp[19-i] = (w.low % 3) + '0';
w.low /= 3;
}
for (i=0;i<10;i++) {
tmp[9-i] = (w.high % 3) + '0';
w.high /= 3;
}
i = 0;
while (tmp[i] == s[0] && i < 20 - min_length) i++;
int j = 2;
while (i < 20) {
s[j] = tmp[i];
i++;
j++;
}
s[j] = 0;
}
unsigned int crazy_low(unsigned int a, unsigned int d){
unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
int position = 0;
unsigned int output = 0;
while (position < 10){
unsigned int i = a%3;
unsigned int j = d%3;
unsigned int out = crz[i+3*j];
unsigned int multiple = 1;
int k;
for (k=0;k<position;k++)
multiple *= 3;
output += multiple*out;
a /= 3;
d /= 3;
position++;
}
return output;
}
Word zero() {
Word result = {0, 0, 0};
return result;
}
Word increment(Word d) {
d.low++;
if (d.low >= 59049) {
d.low = 0;
d.high++;
if (d.high >= 59049) {
fprintf(stderr,"error: overflow\n");
exit(1);
}
}
return d;
}
Word decrement(Word d) {
if (d.low == 0) {
d.low = 59048;
d.high--;
}else{
d.low--;
}
return d;
}
Word crazy(Word a, Word d){
Word output;
unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
output.area = crz[a.area+3*d.area];
output.high = crazy_low(a.high, d.high);
output.low = crazy_low(a.low, d.low);
return output;
}
Word rotate_r(Word d){
unsigned int carry_h = d.high%3;
unsigned int carry_l = d.low%3;
d.high = 19683 * carry_l + d.high / 3;
d.low = 19683 * carry_h + d.low / 3;
return d;
}
// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
if ((mem[d.area])[d.high]) {
return &(((mem[d.area])[d.high])[d.low]);
}
(mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
if (!(mem[d.area])[d.high]) {
fprintf(stderr,"error: out of memory.\n");
exit(1);
}
if (last_initialized) {
Word repitition[6];
repitition[(last_initialized-1) % 6] =
((mem[0])[(last_initialized-1) / 59049])
[(last_initialized-1) % 59049];
repitition[(last_initialized) % 6] =
((mem[0])[last_initialized / 59049])
[last_initialized % 59049];
unsigned int i;
for (i=0;i<6;i++) {
repitition[(last_initialized+1+i) % 6] =
crazy(repitition[(last_initialized+i) % 6],
repitition[(last_initialized-1+i) % 6]);
}
unsigned int offset = (59049*d.high) % 6;
i = 0;
while (1){
((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
if (i == 59048) {
break;
}
i++;
}
}
return &(((mem[d.area])[d.high])[d.low]);
}
unsigned int get_instruction(Word** mem[], Word c,
unsigned int last_initialized,
int ignore_invalid) {
Word* instr = ptr_to(mem, c, last_initialized);
unsigned int instruction = instr->low;
instruction = (instruction+c.low + 59049 * c.high
+ (c.area==1?52:(c.area==2?10:0)))%94;
return instruction;
}
int main(int argc, char* argv[]) {
Word** memory[3];
int i,j;
for (i=0; i<3; i++) {
memory[i] = (Word**)malloc(59049 * sizeof(Word*));
if (!memory) {
fprintf(stderr,"not enough memory.\n");
return 1;
}
for (j=0; j<59049; j++) {
(memory[i])[j] = 0;
}
}
Word a, c, d;
unsigned int result;
FILE* file;
if (argc < 2) {
// read program code from STDIN
file = stdin;
}else{
file = fopen(argv[1],"rb");
}
if (file == NULL) {
fprintf(stderr, "File not found: %s\n",argv[1]);
return 1;
}
a = zero();
c = zero();
d = zero();
result = 0;
while (!feof(file)){
unsigned int instr;
Word* cell = ptr_to(memory, d, 0);
(*cell) = zero();
result = fread(&cell->low,1,1,file);
if (result > 1)
return 1;
if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
break;
instr = (cell->low + d.low + 59049*d.high)%94;
if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
|| cell->low == '\n');
else if (cell->low >= 33 && cell->low < 127 &&
(instr == 4 || instr == 5 || instr == 23 || instr == 39
|| instr == 40 || instr == 62 || instr == 68
|| instr == 81)) {
d = increment(d);
}
}
if (file != stdin) {
fclose(file);
}
unsigned int last_initialized = 0;
while (1){
*ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
*ptr_to(memory, decrement(decrement(d)), 0));
last_initialized = d.low + 59049*d.high;
if (d.low == 59048) {
break;
}
d = increment(d);
}
d = zero();
unsigned int step = 0;
while (1) {
unsigned int instruction = get_instruction(memory, c,
last_initialized, 0);
step++;
switch (instruction){
case 4:
c = *ptr_to(memory,d,last_initialized);
break;
case 5:
if (!a.area) {
printf("%c",(char)(a.low + 59049*a.high));
}else if (a.area == 2 && a.low == 59047
&& a.high == 59048) {
printf("\n");
}
break;
case 23:
a = zero();
a.low = getchar();
if (a.low == EOF) {
a.low = 59048;
a.high = 59048;
a.area = 2;
}else if (a.low == '\n'){
a.low = 59047;
a.high = 59048;
a.area = 2;
}
break;
case 39:
a = (*ptr_to(memory,d,last_initialized)
= rotate_r(*ptr_to(memory,d,last_initialized)));
break;
case 40:
d = *ptr_to(memory,d,last_initialized);
break;
case 62:
a = (*ptr_to(memory,d,last_initialized)
= crazy(a, *ptr_to(memory,d,last_initialized)));
break;
case 81:
return 0;
case 68:
default:
break;
}
Word* mem_c = ptr_to(memory, c, last_initialized);
mem_c->low = translation[mem_c->low - 33];
c = increment(c);
d = increment(d);
}
return 0;
}작동합니다!
답변
PHP , 65 64 61 58 바이트
(빈 문자열) b대신 -1 바이트를 사용하십시오 ''. “b”는 트리밍되므로이 특정 경우 빈 문자열과 같습니다.
substr대신 explode입력을 사용하여 -3 바이트 를 입력합니다.
더 나은 방법을 사용하여 -3 바이트를 감지 1하고 및 -1.
<?=($n=substr($argn,0,-2))?trim($n+1?$n-1?$n:b:'-',b).b:0;테스트 : 온라인으로 사용해보십시오!
“/”앞의 입력의 첫 부분 (이를 호출 함 $n)이 0이면 0을 인쇄합니다.
Else $n는 끝에서 “b”를 자르고 -1과 1의 특수한 경우를 처리하므로 “1”숫자는 인쇄되지 않습니다. 그리고 마지막에 하나의 “b”를 추가합니다. 트리밍 부분은 “3bb”와 같이 끝에 “b”가 두 배가되지 않도록하는 것입니다.
답변
답변
젤리 , 18 바이트
나는 이것에 대한 Erik ‘s ṾṖ$İƑ¡ 를 훔치는 것을 끝내었다 (그렇지 않으면 나는 또한 19를 가질 것이다) …
ṖṖv0ḢṾṖ$İƑ¡,Ạ¡”boḢ
결과를 인쇄하는 전체 프로그램.
온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.
어떻게?
ṖṖv0ḢṾṖ$İƑ¡,Ạ¡”boḢ - Main Link: list of characters S
Ṗ - discard right-most (of S)
Ṗ - discard right-most
0 - literal zero
v - evaluate as Jelly code with right argument (0)
- ... b is covert-to-base, so "nb0" gives [n]
Ḣ - head ([n]->n or n->n)
¡ - repeat...
Ƒ - ...# of times: is invariant under:
İ - reciprocation (n->1/n)
$ - ...action: last two links as a monad:
Ṿ - un-evaluate (-1->"-1" or 1->"1")
Ṗ - discard right-most ("-1"->"-" or "1"->"")
¡ - repeat...
Ạ - ...# of times: all?
, ”b - ...action: pair with a 'b' character
o - logical OR with:
Ḣ - head (S) (i.e. if we end with 0 use the 1st character of the input)
- implicit print
답변
펄 6 , 32 바이트
{~m/^0/||S/[(\-|^)1|b]?\/0/$0b/}입력이 경우 정규 표현식에, 몇 사람이 확인하는 0/0, 다른 하나는 후행를 교체 /0단지와 b(과 제거 된 b, 1및 / 또는 -1)
설명 (이전)
{ } # Anonymous codeblock
~m/^0/ # Return 0 if the input starts with 0
|| # Otherwise
S/ / / # Substitute
\/0 # The /0
( )? # Optionally starting with
<wb>1 # 1 or -1
|b # Or b
b # With just b