Bitflip e negar

42

Dado um número inteiro, faça uma expressão que o produza 0usando negação unária -e complemento bit a bit ~( ~n= -n-1), com os operadores aplicados da direita para a esquerda.

...
-3  = ~-~-~0
-2  = ~-~0
-1  = ~0
 0  = 0
 1  = -~0
 2  = -~-~0
 3  = -~-~-~0
...

Sua expressão deve ser tão curto quanto possível, o que significa que não há partes redundantes de ~~, --, -0, ou 00. Saída ou imprima a expressão como uma sequência ou sequência de caracteres.

Mostrar snippet de código

code-golf  string  math  bitwise 
— xnor
fonte
11
Então ... você quer que abaixemos nossas coisas, inverta e inverta ?
— Jordan
1
espaço em branco entre ~ e 0 permitido?
— Adám 7/09/16
Não, produza exatamente as strings.
— Xnor
2
Obrigatório xkcd.com/153
— Jared Smith

Respostas:

17

Python, 32 bytes

lambda x:("-~"*abs(x))[x<0:]+"0"

Função lambda anônima. Dado que um número inteiro x escreve "- ~" abs (x) vezes e remove o primeiro caractere se x for negativo, um zero será adicionado ao final.

— KarlKastor
fonte
Ah, me derrote.
— mbomb007
Eu escrevi o mesmo também - com nno lugar de xe 'no lugar de ":)
— Jonathan Allan
2
@ JonathanAllan Então você pode seguramente considerá-lo um idiota.
— Erik the Outgolfer
16

JavaScript (ES6), 33 31 bytes

f=x=>x<0?"~"+f(~x):x&&"-"+f(-x)

Recursão <built-ins <loops (pelo menos nesse caso). Basicamente desvaloriza a entrada:

  • se for menor que 0, vire-o e adicione ~a à string;
  • se for maior que 0, negue-o e adicione -a à string;
  • se for exatamente 0, retorne 0.

Aproveita esse padrão:

 0         = 0
-1 = ~( 0) = ~0
+1 = -(-1) = -~0
-2 = ~(+1) = ~-~0
+2 = -(-2) = -~-~0
-3 = ~(+2) = ~-~-~0
+3 = -(-3) = -~-~-~0
etc.
— ETHproductions
fonte
11

Pyth, 14 13 12 Bytes

_<>0Q+0sm"~-

-2 bytes graças a @StevenH.

suíte de teste

Decidi experimentar Pyth, então eu traduzi minha resposta em python . Qualquer ajuda bem-vinda!

Explicação:

_<>0Q+0sm"~-     
        m"~-     # Map "~-" onto the input (= a list of n times "~-").
       s         # Join the list to a string.
     +0          # Add "0" in front. 
 <>0Q            # Slice off the last char if the input is negative.
_                # Reverse the whole thing.
— KarlKastor
fonte
Uso de entrada implícito no fim de poupar um byte: >0em vez de<Q0
— Steven H.
@StevenH. Obrigado! Agora estamos empatados com a resposta mais curta!
— KarlKastor 7/09/16
2
Solução muito diferente (que, infelizmente, não salva bytes):tW>0Q_+0sm"~-
— Steven H.
2
@StevenH. Aumentou a sua solução para 12: _<>0Q+0sm"~-Espero que você esteja bem comigo adicionando isso à minha solução.
— KarlKastor
8

C, 46 bytes

m(x){putchar(x?x<0?126:45:48);x&&m(-x-(x<0));}

Ao contrário da maioria (todas?) Das outras respostas, esta gera os operadores ~e -uma a uma.

— anatolyg
fonte
7

05AB1E , 14 13 bytes

Ä„-~×¹0‹i¦}0J

Explicação

 „-~           # the string "-~"
Ä   ×          # repeated abs(input) times
     ¹0‹i¦}    # if input is negative, remove the first char
           0J  # join with 0

Experimente online!

— Emigna
fonte
7

Perl 38 35 33 (23 + 1 para -p) 24

s/\d+/"-~"x$&.0/e;s;--;

-13 graças a Dada

— Riley
fonte
Você provavelmente quis dizer em -pvez de -r. Além disso, você pode se livrar desses últimos parênteses e ponto e vírgula: if$h<0é suficiente.
— Dada
Eu fiz obrigado. Eu tenho escrito muitas respostas no sed, eu acho.
— Riley
Provavelmente sim. (Se livrar da última 2 parêntese também)
— Dada
Você também pode salvar 2 bytes fazendo em $h<0&&s;.;vez de s/.// if $h<0. ( -pAcrescenta um ;no final do código, então não há necessidade para o último ;de s;.;;E. a if bÉ aproximadamente equivalente a b && a, mas, neste caso, você economiza um byte, porque você pode remover o espaço)
— Dada
Obrigado, eu não sabia -p adicionou um ;também.
— Riley #
6

Dyalog APL , 18 bytes

'0',⍨0∘>↓'-~'⍴⍨2×|

'0',⍨ caractere zero anexado a

0∘> negatividade (ie 1 para números abaixo de 0; 0 para zero e acima)

↓ Caiu de

'-~'⍴⍨ a cadeia "~ -" remodelada ciclicamente para o comprimento

2× duas vezes

| o valor absoluto

+ mais

0∘< positividade (ie 1 para números acima de 0)

TryAPL online!

— Adão
fonte
6

Haskell, 41 bytes

f n=['-'|n>0]++(tail$[1..abs n]>>"-~")++"0"

f n|n<0=tail$f(-n)|x<-[1..n]>>"-~"=x++"0"

Obrigado a nimi por 3 bytes

— BlackCap
fonte
tailfalha para n=0. Você pode usar em seu drop 1lugar.
— nimi
Obrigado @nimi; Eu não tenho nenhuma idéia de como eu perdi isso ..
— Cabeção
1
Não desperdice o guarda de outra forma : f n|n<0=tail.f$abs n|x<-[1..n]>>"-~"=x++"0".
— nimi
1
2 bytes para salvar: ...|n<0=tail$f(-n)|....
— nimi
5

V , 21 bytes

/ä
é
D@"ña-~ñá0kgJó--

Experimente online!

V tem suporte de número muito limitado e, na verdade, não tem conceito de números negativos. Isso significa que, para oferecer suporte a negativos (ou mesmo 0), precisamos usar algumas soluções alternativas.

Explicação:

/ä                  "Move forward to the first digit
é                   "And enter a newline
D                   "Delete this number, into register '"'
 @"                 "That number times:
   ñ   ñ            "Repeat the following:
    a               "  Append the string:
     -~             "  '-~'
        á0          "Append a 0
          k         "Move up a line
           gJ       "And join these two lines together
             ó--    "Remove the text '--', if it exists
— DJMcMayhem
fonte
5

JavaScript (ES6), 39 37 bytes

x=>"-~".repeat(x<0?-x:x).slice(x<0)+0

Guardado 2 bytes graças a @Neil

— Huntro
fonte
5

Gelatina , 10 bytes

A⁾-~ẋḊẋ¡N0

Este é um programa completo. Experimente online!

Como funciona

A⁾-~ẋḊẋ¡N0  Main link. Argument: n

A           Take the absolute value of n.
 ⁾-~ẋ       Repeat the string "-~" that many times. Result: s
       ¡    Conditional application:
     Ḋ        Dequeue; remove the first element of s...
      ẋ N     if s, repeated -n times, is non-empty.
         0  Print the previous return value. Set the return value to 0.
            (implicit) Print the final return value.
— Dennis
fonte
5

Java 7, 95 79 bytes

79 bytes:

String s(int x){String t=x<0?"~":"";while((x<0?++x:x--)!=0)t+="-~";return t+0;}

Ungolfed:

String s(int x) {
    String t = x<0 ? "~" : "";
    while((x<0 ? ++x : x--) != 0)
        t += "-~";
    return t+0;
}

Versão antiga (95 bytes):

String s(int x){return new String(new char[x<0?-x:x]).replace("\0","-~").substring(x<0?1:0)+0;}

Uso:

class A {
    public static void main(String[]a) {
        System.out.println(s(-3));
        System.out.println(s(-2));
        System.out.println(s(-1));
        System.out.println(s(0));
        System.out.println(s(1));
        System.out.println(s(2));
        System.out.println(s(3));
    }
    static String s(int x){String t=x<0?"~":"";while((x<0?++x:x--)!=0)t+="-~";return t+0;}
}

Experimente aqui!

Saída:

~-~-~0
~-~0
~0
0
-~0
-~-~0
-~-~-~0
— QBrute
fonte
Olá, e bem-vindo ao PPCG! Bom primeiro post!
— Rɪᴋᴇʀ
Bem-vindo ao PPCG! Hmm, essa é uma solução mais curta que a minha, então excluirei minha resposta e votarei a sua em seu lugar. :)
— Kevin Cruijssen
3

EXCEL: 55 33 bytes

=REPT("-~",IF(A1>0,A1,ABS(A1)-1))&"0"

A entrada está na forma de colocar um número na célula A1. A fórmula pode ir a qualquer lugar, exceto A1.

Eu não acho que ele funciona para números negativos ...
— Pajonk
3

T-SQL, 87 bytes

select substring(replicate('-~',abs(x)),case when x<0then 2 else 1 end,x*x+1)+'0'from #

A x*x+1condição na substring é suficiente, pois x^2+1>=2*abs(x)para todos x.

Como geralmente no SQL, a entrada é armazenada em uma tabela:

create table # (x int)

insert into # values (0)
insert into # values (1)
insert into # values (-1)
insert into # values (2)
insert into # values (-2)
— pajonk
fonte
3

CJam , 18 14 bytes

Inspirou-se na resposta de Emigna para economizar 4 bytes.

li_z"-~"*\0<>0

Experimente online! (Como um conjunto de testes separado por avanço de linha.)

Explicação

li      e# Read input and convert to integer N.
_z      e# Duplicate and get |N|.
"-~"*   e# Repeat this string |N| times.
\0<     e# Use the other copy of N to check if it's negative.
>       e# If so, discard the first '-'.
0       e# Put a 0 at the end.
— Martin Ender
fonte
3

Vim - 31 pressionamentos de tecla

Primeiro golfe vim, prolly perdeu uma tonelada de coisas.

`i-~<esc>:s/-\~-/\~-/dwp<left>ii<esc><left>d$@"<esc>a0`
— Maltysen
fonte
Bem-vindo ao clube! :) Você poderia fazer em :s/^-vez de :s/-\~/\~-e em Dvez ded$
— DJMcMayhem
Agora que penso nisso, não acho que isso lide com 0. Você pode contornar isso incrementando antes de excluir <C-a>e excluir dois caracteres no final.
— DJMcMayhem
@DJMcMayhem oh, 0inão funciona?
— Maltysen 9/09/16
Não, infelizmente não. 0move o cursor para o primeiro caractere na linha atual. Você pode usar 0 como uma contagem em V.
— DJMcMayhem
2

Matlab, 61 bytes

x=input('');A=repmat('-~',1,abs(x));disp([A((x<0)+1:end) 48])
— pajonk
fonte
2

Perl 6 , 25 bytes

{substr '-~'x.abs~0,0>$_}

Explicação:

{
  substr
    # string repeat ｢-~｣ by the absolute value of the input
    '-~' x .abs

    # concatenate 0 to that
    ~ 0

    ,

    # ignore the first character of the string if it is negative
    0 > $_
}
— Brad Gilbert b2gills
fonte
2

Geléia, 14 12 bytes

-2 bytes graças a @Dennis (retorne 0 em vez de concatenar "0", tornando este um programa completo apenas).

0>‘
A⁾-~ẋṫÇ0

Teste em TryItOnline

Quão?

0>‘      - link 1 takes an argument, the input
0>       - greater than 0? 1 if true 0 if false
  ‘      - increment

A⁾-~ẋṫÇ0 - main link takes an argument, the input
      Ç  - y = result of previous link as a monad
A        - x = absolute value of input
 ⁾-~     - the string "-~"
    ẋ    - repeat the sting x times
     ṫ   - tail repeatedString[y:] (y will be 1 or 2, Jelly lists are 1-based)
       0 - implicit print then return 0
— Jonathan Allan
fonte
2

> <>, 18 + 3 = 22 bytes

:?!n0$-:0):1go-
-~

Experimente online! +3 bytes para o ​ -vsinalizador inicializar a pilha com a entrada. Se supor que STDIN está vazio estiver correto, o seguinte é um byte mais curto:

:?!ni*:0):1go-
-~

O programa continua lançando a entrada nconforme necessário até atingir 0, após o que ocorre um erro.

[Loop]
:?!n      If n is 0, output it as a num. If this happens then the stack is now
          empty, and the next subtraction fails
0$-       Subtract n from 0
:0)       Push (n > 0)
:1go      Output the char at (n>0, 1) which is a char from the second line
-         Subtract, overall updating n -> -n-(n>0)
— Sp3000
fonte
2

Oitava, 51 bytes

x=input('');[("-~"'*[1:abs(x)>0])((x<0)+1:end),'0']

A princípio, copiando descaradamente a abordagem Matlab por @pajonk e modificando alguns detalhes, reescrevendo como um "produto externo" entre um vetor de uns e os caracteres "- ~" e abusando da indexação on-the-fly (ou o que poderia ser chamado) permite salvar alguns bytes. Ainda me dói um pouco que eu não consiga que a expressão de índice use menos bytes.

A oitava permite a (i1) (i2) ou mesmo (...) (i1) (i2) a indexação em que o Matlab deseja que armazenemos variáveis ​​entre as indexações.

((x<0)+1:end)

é muito longo para descrever "pular primeiro se". Deve haver uma maneira melhor.

— mathreadler
fonte
2

PseudoD , 688 579 521 bytes

utilizar mate.pseudo
utilizar entsal.pseudo
adquirir n
adquirir a
adquirir r
adquirir i
fijar n a llamar LeerPalabra finargs
si son iguales n y CERO
escribir {0}
salir
fin
fijar a a llamar ValorAbsoluto n finargs
fijar i a CERO
si comparar Importar.Ent.Comparar n < CERO
fijar r a {~}
sino
fijar r a {-}
fin
mientras comparar Importar.Ent.Comparar i < a
escribir r finargs
si son iguales r y {~}
fijar r a {-}
Importar.Ent.Sumar i UNO i
sino
fijar r a {~}
fin
finbucle
si son iguales r y {~}
escribir {~}
fin
escribir {0}

Explicar:

Read a number from STDIN;
If the number is zero (0); Then:
    Writes 0 to STDOUT and exits;
End If;
If the number is less than zero (0); Then:
    Set the fill character to "~";
Else:
    Set the fill character to "-";
End If;
For i = 0; While i is less than abs(number); do:
    Write the fill character to STDOUT;
    If the fill character is "~":
        Set the fill character to "-"
        Increment i by one
    Else:
        Set the fill character to "~"
    End if;
End for;
If the fill character is "~"; Then:
    Write "~" to STDOUT;
End If;
Write "0" to STDOUT
— alinarezrangel
fonte
1
Bem-vindo ao PPCG! Isso é tão pequeno quanto possível? Vejo alguns identificadores longos que você provavelmente poderia encurtar ("relleno" para "r", menos relleno: P). Eu acho que você pode descartar as importações da lib padrão se for apenas uma função ou um trecho de código também. Ele não solicita nova linha na saída, portanto, talvez você possa alterar o último EscribirLinea para Escribir. Você pode atribuir funções a nomes mais curtos ( adquirir e``fijar p a Escribir)?
— fede s.
1

PHP, 58 bytes

<?=((0<$a=$argv[1])?'-':'').str_pad('0',2*abs($a),'~-',0);
— Crypto
fonte
1

Labirinto , 25 bytes

`?+#~.
.  ; 6
54_"#2
  @!

Experimente online!

Explicação

Eu realmente gosto do fluxo de controle neste. O IP é executado na figura 8 (ou na verdade um a, eu acho) através do código para reduzir a entrada lentamente para 0imprimir os caracteres correspondentes.

O código começa no canto superior esquerdo, indo para a direita. O `não faz nada agora. ?lê a entrada e a +adiciona ao zero implícito abaixo. É claro que isso também não faz nada, mas quando repassarmos esse código novamente, ?enviaremos um zero (porque estamos no EOF) e +depois nos livraremos desse zero.

Em seguida, #aumenta a profundidade da pilha, simplesmente para garantir que haja um valor positivo na pilha para fazer o IP virar para o sul e ;descartá-lo novamente.

O "é um no-op e atua como o ramo principal do código. Existem três casos para distinguir:

  • Se o valor atual for positivo, o IP vira à direita (oeste) e completa uma rodada do loop esquerdo:

    _45.`?+
_45      Push 45.
   .     Print as character '-'.
    `    Negate the current value (thereby applying the unary minus).
     ?+  Does nothing.

  • Se o valor atual for negativo, o IP vira à esquerda (leste) e o seguinte código é executado:

    #26.~
#        Push stack depth, 1.
 26      Turn it into a 126.
   .     Print as character '~'.
    ~    Bitwise NOT of the current value (applying the ~).

    Observe que esses dois se alternam (já que ambos alteram o sinal da entrada) até que o valor da entrada seja reduzido a zero. Nesse ponto...

  • Quando o valor atual é zero, o IP simplesmente continua se movendo para o sul e executa oe !depois vira para oeste na direção do @. !imprime 0e @finaliza o programa.
— Martin Ender
fonte
1

GolfScript ,30 24 20 bytes

  • Economizou 6 bytes graças ao xnor.
  • Economizou 4 bytes graças a Dennis.

~."-~"\abs*\0<{(;}*0

Entrada: -5

Saída: -5 = ~-~-~-~-~0

Explicação

~.     # Input to integer and duplicate
"-~"   # We shall output a repetition of this string
\abs   # Move the input onto the stack and computes abs
*      # Multiply "-~" for abs(input) times
\      # Copy onto the stack the input
0<     # Is it less than 0?
{(;}*  # Yes: remove first '-' from the output
0      # Push 0

Experimente online!

— FedeWar
fonte
1
Você não precisa imprimir 2 = , apenas o -~-~0.
— xnor
1
Você pode usar em {(;}*0vez de {(;}{}if 0.
— Dennis
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.