Fique longe de zero

41

Tarefa

Dado um número inteiro não negativo n, emita 1se né 0e emita o valor de noutro modo.

Entrada

Um número inteiro não negativo.

  • Se você gostaria de aceitar a string como entrada, a string corresponderia ao seguinte regex:, /^(0|[1-9][0-9]*)$/ou seja, ela não deve ter zeros à esquerda, exceto quando estiver 0.
  • Se você aceitar um número inteiro real como entrada, poderá assumir que o número inteiro está dentro da capacidade de manipulação do idioma.

Saída

Um número inteiro positivo, especificado acima. Zeros à esquerda não são permitidos. Sua saída deve corresponder ao regex /^[1-9][0-9]*$/.

Casos de teste

input output
    0      1
    1      1
    2      2
    3      3
    4      4
    5      5
    6      6
    7      7

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Aplicam-se brechas padrão .

code-golf  number  integer 
— Freira Furada
fonte
11
Você provavelmente deve colocar um link para o TNB CMC , pois é daí que esse desafio surgiu.
— Mbomb007
A resposta precisa ser uma função completa ou pode ser o corpo?
— Caleb Kleveter
11
@CalebKleveter A regra padrão no PPCG é que a resposta é uma função ou um programa completo, mas não trechos.
— Leaky Nun
Podemos imprimir a saída com um zero à esquerda?
— MD XF
@MDXF sim, você pode.
— Leaky Nun

Respostas:

18

C (gcc), 14 13 bytes

f(n){n=n?:1;}

Agradeço à @betseg por me lembrar do n?:1truque nos comentários da outra resposta C!

Experimente online!

C, 17 bytes

f(n){return!n+n;}

Experimente online!

C, 16 bytes

#define f(n)!n+n

Experimente online!

— Steadybox
fonte
— betseg 2/17/17
11
@betseg Isso é porque é uma macro. O compilador vê como 3*!n+nigual 3*0+5.
— Steadybox
11
Eu sei, mas acho que você deve poder aplicar operadores aritméticos aos valores "return" diretamente, é por isso que é prática comum colocar parênteses em torno de macros. Só não acho que a macro seja válida.
— betseg 2/17/17
4
@ beteg Não acho que isso seja um requisito no código de golfe. Eu nunca vi uma resposta de código de golfe com macros C fazer isso.
— Steadybox
11
@ hucancode Veja os links do TIO. Você precisa adicionar um a mainpartir do qual a função / macro fé chamada. Uma solução não precisa ser um programa completo por padrão. A versão específica do gcc pode ou não ser compilada em outro compilador e pode ou não ser executada corretamente quando compilada em outro compilador.
— Steadybox
17

Japonês , 2 bytes

ª1

Experimente online!

Explicação

ªé um atalho para o ||operador de JS . Japt tem entrada implícita, portanto, este programa calcula input||1e o resultado é enviado implicitamente para STDOUT.

w1também funcionaria, aproveitando ao máximo a entrada e 1.

— ETHproductions
fonte
16

Alice , 7 bytes

1/s
o@i

Experimente online!

Explicação

1   Push 1. Irrelevant.
/   Reflect to SE. Switch to Ordinal.
i   Read all input as a string.
    Reflect off bottom right corner. Move back NW.
/   Reflect to W. Switch to Cardinal.
1   Push 1.
    IP wraps around to last column.
s   Sort swap: implicitly convert the input to an integer. Then, if the top stack 
    element is less than the one below, the two are swapped. It basically computes
    min and max of two values at the same time, with max on top.
/   Reflect to NW. Switch to Ordinal.
    Immediately reflect off the top boundary. Move SW.
o   Implicitly convert the result to a string and print it.
    Reflect off bottom left corner. Move back NE.
/   Reflect to S. Switch to Cardinal.
@   Terminate the program.
— Martin Ender
fonte
15

JavaScript (ES6), 7 bytes

n=>n||1
— Arnauld
fonte
5
Alternativa: n=>n+!n(Pelo menos eu acho)
— Matthew Roh
@SIGSEGV Sim, isso realmente funcionaria. (Isso também poderia ser n|!n, embora este é limitado a uma quantidade de 31 bits.)
— Arnauld
isso pode ser simplificado para n || 1. A única coisa que é avaliada como falsa é 0.
— ansiart
11
@ansiart Se o seu ponto é que n=>n||1poderia ser simplificado n||1, então não. Respostas aceitáveis ​​são programas ou funções completos. n=>do_something_with(n)é uma função de seta na sintaxe do ES6.
— Arnauld
11
@StanStrum Somos obrigados a retornar o valor original de nse não for zero. Um OR bit a bit seria modificado nsempre que o bit menos significativo não estiver definido (por exemplo (4|1) === 5).
— Arnauld
12

Retina , 4 bytes

^0
1

Experimente online!

Se a entrada começar com um zero, substitua-a por um 1. (Funciona porque é garantido que a entrada não possui zeros à esquerda para valores diferentes de zero).

— Martin Ender
fonte
12

V , 4 bytes

é0À

Experimente online!

Abusa de um comportamento não preferido, mas esperado , então não posso chamá-lo de bug. Explicação:

No Vim, os comandos aceitam uma contagem. Por exemplo, <C-a>incrementará um número, mas 7<C-a>incrementará um número em 7. No entanto, você não pode usar 0como uma contagem, porque

  • 0 já é um comando (vá para a primeira coluna) e

  • No contexto de um editor de texto, raramente faz sentido solicitar que um comando seja executado 0 vezes.

Isso é bom para um editor de texto, mas geralmente desagradável para uma linguagem de golfe; portanto, V substitui alguns comandos para que 0seja uma contagem válida. Por exemplo, é, ñ, Ä, e alguns outros. No entanto, como <C-a>é um comando interno do vim, ele não é sobrescrito, portanto, executar isso com uma entrada positiva fornece:

N       " N times:
 <C-a>  "   Increment

Mas rodar com 0 como entrada fornece:

0       " Go to column one
 <C-a>  " Increment

Explicação completa:

é0          " Insert a 0
  À         " Arg1 or 1 times:
   <C-a>    " Increment
— DJMcMayhem
fonte
11
A única vez que 0não ser uma contagem é útil. Eu nem sequer considerá-lo no início porque eu tenho evitado isso tantas vezes
— nmjcman101
12

Haskell, 5 bytes

max 1

Exemplo de uso: (max 1) 0-> 1.

Não há muito o que explicar.

— nimi
fonte
10

R, 13 bytes

max(1,scan())

lê nde stdin. Com pmax, ele pode ler em uma lista e retornar o valor apropriado para cada elemento da lista para +1 byte.

experimente online!

Devo observar que há outra solução R fina em 13 bytes por Sven Hohenstein que permite outra solução de 13 bytes de

(n=scan())+!n

o que me faz pensar se esse é o limite mais baixo para R.

— Giuseppe
fonte
Outra 13 bytes solução usando pryr: pryr::f(n+!n). Não consegue encontrar qualquer coisa menor ...
— Jayce
9

Cubix , 6 bytes

OI!1L@

De alguma forma, conseguiu encaixá-lo em um cubo de unidade ... Teste on-line!

Explicação

Antes de ser executado, o código é organizado como uma rede de cubos:

  O
I ! 1 L
  @

O IP (ponteiro de instrução) é então colocado na face esquerda extrema ( I), voltada para a direita. As instruções executadas a partir daí são:

I  Input a number from STDIN and push it to the stack.
!  If the top number is non-zero, skip the next instruction.
1  Push a 1 (only if the input was zero).
L  Turn left. The IP is now on the top face facing the !.
O  Output the top item as a number.

O IP atinge !novamente, ignorando a @parte inferior da face. Isso não é útil, pois precisamos pressionar o botão @para finalizar o programa. O IP bate Lnovamente e passa pela linha do meio em reverse ( L1!I) antes de terminar Lmais uma vez, o que finalmente transforma o IP @.

— ETHproductions
fonte
5

Braquilog , 3 bytes

∅1|

Experimente online!

Explicação

Se adicionarmos o implícito ?(Input) e .(Output), teremos:

?∅          Input is empty (that is, [] or "" or 0 or 0.0)
  1.        Output = 1
    |       Else
     ?.     Input = Output
— Fatalizar
fonte
5

MarioLANG , 12 bytes

;
=[
:<+
 =:

Experimente online!

Como funciona

Mario começa no canto superior esquerdo, inicialmente andando para a direita. Ele lê um int de input ( ;) e o armazena na célula de memória atual. Então ele cai do chão ( =), batendo [, o que o faz ignorar o próximo comando se a célula atual for 0.

Se a célula não for 0, ele começará a andar para a esquerda ( <), produzirá a célula atual como int ( :) e morrerá (final do programa).

Se a célula for 0, ele ignora o comando para virar à esquerda e continua andando à direita. Ele incrementa a célula atual ( +), a produz e cai até a morte.

— Gato de negócios
fonte
5

Flak cerebral , 22 , 10 bytes

({{}}[]{})

Experimente online!

Explicação:

Se a entrada for diferente de zero, {{}}irá retirar tudo da pilha e avaliar a entrada. Se for zero, nada será exibido e será avaliado como zero. Então, correr ({{}})dá

Diferente de zero:

n

Zero:

0
0

Nesse ponto, adicionaremos a altura da pilha (0 para diferente de zero, 1 para zero) e exibiremos mais um valor da pilha. (como a pilha é preenchida com um número infinito de zeros, isso exibirá os 0 primeiros ou 0 extra)

— DJMcMayhem
fonte
Bom trabalho, mas não a solução mais curta: codegolf.stackexchange.com/a/118520/31203
— MegaTom
4

TI-BASIC, 7 bytes

:Prompt X
:X+not(X

Alternativamente,

TI-BASIC, 7 bytes

:Prompt X
:max(X,1
— Scott Milner
fonte
4

Python, 15 bytes

lambda n:n or 1
— daniero
fonte
Por que não apenas n or 16 bytes?
— DRsPreço
2
Porque isso é apenas um trecho, enquanto normalmente respondemos com programas ou funções completos. Não tenho certeza se isso é declarado explicitamente em algumas regras em algum lugar, mas pelo menos esse é o padrão de fato.
— Daniero 4/04
Citando trichoplax : The rules are not terribly clear. I think we have a consensus on meta that REPLs count, but as a separate language, which would allow snippets in many cases, but snippets are not permitted according to this meta post-> codegolf.meta.stackexchange.com/questions/2419/…
— daniero 4/17
@trichoplax 1or nsempre voltava 1, não?
— Daniero 4/04
11
Alternativa com a mesma contagem de bytes de 15 bytes:lambda n:n|1>>n
— Kevin Cruijssen 13/18
4

dc, 11 bytes

[1]sf?d0=fp

[1]sfarmazena uma macro no registro f que empurra 1 para o topo da pilha, ?lê a entrada, d0=fexecuta a macro f se a entrada for 0, pimprime a parte superior da pilha.

Teste:

$ dc -e "[1]sf?d0=fp" <<< 0
1
$ dc -e "[1]sf?d0=fp" <<< 1
1
$ dc -e "[1]sf?d0=fp" <<< 42
42
— daniero
fonte
4

Excel, 10 bytes

=A1+(A1=0)

Isso economiza 4 bytes sobre a solução óbvia da instrução 'IF' =IF(A1=0,1,A1),.

— qoou
fonte
3
E 1 byte a menos que o menos óbvio=A1+NOT(A1)
— Engineer Toast
4

Java 8, 10 bytes

i->i<1?1:i
  • Obrigado a @LeakyNun por economizar - 1 byte
    • Não percebeu que é um número inteiro não negativo
— Roman Gräf
fonte
3
i==0pode ser substituído pori<1
— Leaky Nun
4

R, 13 bytes

n=scan();n+!n

Aqui, scané usado para ler o valor de entrada n. A negação de n(ou seja, !n0 ou 1) é adicionada a n.

— Sven Hohenstein
fonte
3

Mathematica, 9 8 bytes

Por Martin Ender:

#~Max~1&

Primeira ideia:

#/. 0->1&

A função pura substitui 0por 1. O espaço é necessário ou pensa que estamos dividindo .0.

— ngenisis
fonte
3

Perl 5, 6 + 2 bytes para os sinalizadores -l e -p

$_||=1

Recebe entrada em linhas separadas do stdin. Corre com as bandeiras -lp.

— Chris
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.