Bitflip e negare

42

Dato un numero intero, crea un'espressione che la produca 0usando la negazione unaria -e il complemento bit a bit ~( ~n= -n-1), con gli operatori applicati da destra a sinistra.

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

L'espressione deve essere il più breve possibile, il che significa parti ridondanti di ~~, --, -0, o 00. Stampa o stampa l'espressione come una stringa o una sequenza di caratteri.

Mostra snippet di codice

code-golf  string  math  bitwise 
— XNOR
fonte
11
— Giordania,
1
spazio tra ~ e 0 consentito?
— Adám,
No, genera esattamente le stringhe.
— xnor
2
Obbligatorio xkcd.com/153
— Jared Smith

Risposte:

17

Python, 32 byte

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

Funzione lambda anonima. Dato un numero intero x scrive "- ~" abs (x) volte e rimuove il primo carattere se x è negativo, quindi viene aggiunto uno zero alla fine.

— KarlKastor
fonte
Aw, battimi.
— mbomb007,
Ho appena scritto lo stesso - con nal posto di xe 'al posto di ":)
— Jonathan Allan,
2
@JonathanAllan Quindi puoi tranquillamente considerarlo un duplicato.
— Erik the Outgolfer,
16

JavaScript (ES6), 33 31 byte

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

Cicli di ricorsione <built-in <(almeno in questo caso). Fondamentalmente sottovaluta l'input:

  • se è inferiore a 0, capovolgilo e aggiungi ~a alla stringa;
  • se è maggiore di 0, negalo e aggiungi -a alla stringa;
  • se è esattamente 0, restituisce 0.

Sfrutta questo schema:

 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 byte

_<>0Q+0sm"~-

-2 byte grazie a @StevenH.

suite di test

Ho deciso di provare Pyth, quindi ho tradotto la mia risposta Python . Qualsiasi aiuto benvenuto!

Spiegazione:

_<>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
Utilizzare l'input implicito alla fine per salvare un byte: >0anziché<Q0
— Steven H.
@StevenH. Grazie! Ora siamo in pareggio con la risposta più breve!
— KarlKastor,
2
Soluzione molto diversa (che, sfortunatamente, non salva alcun byte):tW>0Q_+0sm"~-
— Steven H.
2
@StevenH. Sconfitto la tua soluzione fino a 12: _<>0Q+0sm"~-spero che tu stia bene aggiungendo questo alla mia soluzione.
— KarlKastor,
8

C, 46 byte

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

A differenza della maggior parte (tutte?) Delle altre risposte, questa emette gli operatori ~e -uno alla volta.

— anatolyg
fonte
7

05AB1E , 14 13 byte

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

Spiegazione

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

Provalo online!

— Emigna
fonte
7

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

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

-13 grazie a Dada

— Riley
fonte
Probabilmente intendevi -pinvece di -r. Inoltre puoi sbarazzarti di quelle ultime parentesi e punto e virgola: if$h<0è abbastanza.
— Dada,
L'ho fatto, grazie. Ho scritto troppe risposte in sed immagino.
— Riley,
Probabilmente sì. (Sbarazzati anche delle ultime 2 parentesi)
— Dada,
Puoi anche salvare 2 byte facendo $h<0&&s;.;invece di s/.// if $h<0. ( -paggiunge ;a alla fine del codice, quindi non è necessario per l'ultimo ;di s;.;;. Ed a if bè approssimativamente equivalente a b && a, ma in questo caso ti fa risparmiare un byte perché puoi rimuovere lo spazio)
— Dada,
Grazie, non sapevo -p ha aggiunto ;anche un .
— Riley,
6

Dyalog APL , 18 byte

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

'0',⍨ carattere zero aggiunto a

0∘> negatività (ovvero 1 per numeri inferiori a 0; 0 per zero e su)

↓ caduto da

'-~'⍴⍨ la stringa "~ -" è stata ridimensionata ciclicamente in lunghezza

2× due volte

| il valore assoluto

+ più

0∘< positività (ovvero 1 per numeri superiori a 0)

ProvaAPL online!

— Adamo
fonte
6

Haskell, 41 byte

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

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

Grazie a nimi per 3 byte

— Capinera
fonte
tailfallisce per n=0. Puoi usare drop 1invece.
— nimi,
@nimi Grazie; Non ho idea di come mi sia perso ..
— BlackCap
1
Non sprecare il altrimenti guardia : f n|n<0=tail.f$abs n|x<-[1..n]>>"-~"=x++"0".
— nimi,
1
2 byte per salvare: ...|n<0=tail$f(-n)|....
— nimi,
5

V , 21 byte

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

Provalo online!

V ha un supporto numerico molto limitato e in realtà non ha il concetto di numeri negativi. Questo significa che per supportare i negativi (o anche lo 0), dobbiamo usare alcune soluzioni alternative.

Spiegazione:

/ä                  "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 byte

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

Salvato 2 byte grazie a @Neil

— Huntro
fonte
5

Gelatina , 10 byte

A⁾-~ẋḊẋ¡N0

Questo è un programma completo. Provalo online!

Come funziona

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 byte

79 byte:

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;
}

Vecchia versione (95 byte):

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;}
}

Provalo qui!

Produzione:

~-~-~0
~-~0
~0
0
-~0
-~-~0
-~-~-~0
— QBrute
fonte
Ciao e benvenuto in PPCG! Bel primo post!
— Rɪᴋᴇʀ
Benvenuti in PPCG! Hmm, questa è una soluzione più breve della mia, quindi eliminerò la mia risposta e valuterò invece la tua. :)
— Kevin Cruijssen l'
3

EXCEL: 55 33 byte

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

L'input è nella forma di inserire un numero nella cella A1. La formula può andare ovunque tranne A1.

Non credo che funzioni con numeri negativi ...
— pajonk,
3

T-SQL, 87 byte

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

La x*x+1condizione nella sottostringa è sufficiente, poiché x^2+1>=2*abs(x)per tutti x.

Come di solito in SQL, l'input è archiviato in una tabella:

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 byte

Ha preso ispirazione dalla risposta di Emigna per salvare 4 byte.

li_z"-~"*\0<>0

Provalo online! (Come una suite di test separata da avanzamento riga.)

Spiegazione

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 sequenze di tasti

Prima vim golf, molte volte ho perso un sacco di cose.

`i-~<esc>:s/-\~-/\~-/dwp<left>ii<esc><left>d$@"<esc>a0`
— Maltysen
fonte
Bello, benvenuto nel club! :) Si potrebbe fare :s/^-invece :s/-\~/\~-e Dinvece did$
— DJMcMayhem
Ora che ci penso, non penso che questo gestisca 0. Potresti aggirare questo incrementando prima di cancellare con <C-a>e poi cancellare due caratteri alla fine.
— DJMcMayhem
@DJMcMayhem oh, 0inon funziona?
— Maltysen,
No, sfortunatamente no. 0sposta il cursore sul primo carattere della riga corrente. Puoi comunque usare 0 come conteggio in V.
— DJMcMayhem
2

Matlab, 61 byte

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

Perl 6 , 25 byte

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

Spiegazione:

{
  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

Gelatina, 14 12 byte

-2 byte grazie a @Dennis (restituisce 0 anziché concatenare "0", rendendolo solo un programma completo.)

0>‘
A⁾-~ẋṫÇ0

Provalo su TryItOnline

Come?

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 byte

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

Provalo online! +3 byte per il ​ -vflag per inizializzare lo stack con l'input. Se supponendo che STDIN sia vuoto va bene, allora quanto segue è un byte più breve:

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

Il programma continua a invertire l'input nsecondo necessità fino a quando non raggiunge 0, dopodiché si interrompe.

[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

Ottava, 51 byte

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

Inizialmente copiando palesemente l'approccio Matlab di @pajonk e poi modificando alcuni dettagli, riscrivendolo come "prodotto esterno" tra un vettore di quelli e i caratteri "- ~" e abusando dell'indicizzazione al volo (o di ciò che potrebbe essere chiamato) ci consente di salvare alcuni byte. Mi fa ancora un po 'male il fatto che non riesco a ottenere l'espressione dell'indice per prendere meno byte.

Octave consente a (i1) (i2) o anche (...) (i1) (i2) per l'indicizzazione in cui Matlab vorrebbe che memorizzassimo le variabili tra le indicizzazioni.

((x<0)+1:end)

è troppo lungo per descrivere "salta prima se". Deve esserci un modo migliore.

— mathreadler
fonte
2

PseudoD , 688 579 521 byte

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}

Spiegare:

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
Benvenuti in PPCG! È così piccolo? Vedo alcuni identificatori lunghi che potresti probabilmente abbreviare (da "relleno" a "r", menos relleno: P). Penso che puoi eliminare le importazioni per lib standard se è solo una funzione o un frammento di codice. Non richiede la nuova riga finale in uscita, quindi forse puoi modificare l'ultima EscribirLinea in Escribir. Puoi assegnare funzioni a nomi più brevi ( adquirir e``fijar p a Escribir)?
— fede s.
1

PHP, 58 byte

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

Labirinto , 25 byte

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

Provalo online!

Spiegazione

Mi piace molto il flusso di controllo in questo. L'IP scorre in una figura 8 (o in realtà un ∞, immagino) attraverso il codice per ridurre lentamente l'input 0durante la stampa dei caratteri corrispondenti.

Il codice inizia nell'angolo in alto a sinistra andando a destra. Al momento `non fa nulla. ?legge l'input e lo +aggiunge allo zero implicito di seguito. Ovviamente anche questo non fa nulla, ma quando ci imbattiamo di nuovo in questo codice, ?spingerà uno zero (perché siamo in EOF) e +poi ci libereremo di quello zero.

Successivamente #spinge la profondità dello stack, semplicemente per garantire che ci sia un valore positivo sullo stack per far girare l'IP verso sud e ;scartarlo di nuovo.

La "è un no-op e agisce come il ramo principale del codice. Esistono tre casi per distinguere:

  • Se il valore corrente è positivo, l'IP gira a destra (ovest) e completa un giro del loop sinistro:

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

  • Se il valore corrente è negativo, l'IP gira a sinistra (est) e viene eseguito il seguente codice:

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

    Si noti che questi due si alterneranno (poiché entrambi modificano il segno dell'ingresso) fino a quando il valore di ingresso non viene ridotto a zero. A quel punto...

  • Quando il valore corrente è zero, l'IP continua semplicemente a spostarsi verso sud, esegue il !e poi gira ad ovest sul @. !stampa 0e @termina il programma.
— Martin Ender
fonte
1

GolfScript ,30 24 20 byte

  • 6 byte salvati grazie a xnor.
  • Salvato 4 byte grazie a Dennis.

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

Ingresso: -5

Produzione: -5 = ~-~-~-~-~0

Spiegazione

~.     # 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

Provalo online!

— FedeWar
fonte
1
Non è necessario stampare il 2 = , solo il -~-~0.
— xnor,
1
Puoi usare {(;}*0invece di {(;}{}if 0.
— Dennis,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.