Moi pense qu'il n'y a pas assez de questions faciles ici que les débutants peuvent essayer!
Le défi: Avec une chaîne d'entrée aléatoire composée de 1 et de 0 tels que:
10101110101010010100010001010110101001010
Ecrivez le code le plus court qui produit l'inverse en bits, comme suit:
01010001010101101011101110101001010110101
Réponses:
Suppose que la chaîne d'entrée est dans variable b.
b='0'
Cela ne fait pas ce qu’il ferait dans la plupart des langues ...
L'opérateur de comparaison J est juste
=(=:et=.sont des affectations globales et locales, respectivement). Cependant,=cela ne fonctionne pas comme un==opérateur normal : il compare élément par élément. Gardez à l' esprit qu'un tableau est formé comme suit:0 2 3 2 3 1 2 3 4.2 = 0 2 3 2 3 1 2 3 4donne0 1 0 1 0 0 1 0 0par exemple. Ceci est similaire pour une chaîne:'a'='abcadcadda'ne retourne pas simplement0, elle retourne1 0 0 1 0 0 1 0 0 1(ceci peut être extrapolé à signifier0avec*/, ce qui signifie fondamentalementall.) Dans ce cas cependant, ce comportement est excellent, puisque nous voulons une chaîne de uns et de zéros, ou vrai et faux. Puisque les bools de J sont1et0, cela donne un tableau de1et0's (ce ne sont pas des chaînes, et tout autre caractère que cela1aurait également pour résultat0dans ce tableau.) Cela n'a pas besoin d'être imprimé: J imprime automatiquement le résultat d'une expression. J'espère que c'était une explication adéquate, sinon demandez s'il vous plaît quelque chose qui n'est pas encore clair dans les commentaires. Cette réponse aurait également pu être'0'&=(ou=&'0'), mais j’ai pensé queb='0'c’était plus clair.
=&'0'fonctionne pour le même nombre d'octets.
{1^}%
GolfScript lit l'intégralité de l'entrée de STDIN et la place sur la pile en tant que chaîne.
{}% parcourt tous les caractères de la chaîne et exécute le bloc de code pour chacun d'eux.
1^ calcule le OU exclusif des caractères du code ASCII avec 1. «0» correspond au code ASCII 48, «1» au code ASCII 49.
Depuis 48 ^ 1 = 49et 49 ^ 1 = 48, cela transforme les 0 en 1 et les 1 en 0.
Une fois terminé, GolfScript imprime la chaîne modifiée.
q1f^
Chaque caractère de
ce x est composé de 1. À la différence de l'autre réponse de CJam, je ne suppose pas que l'entrée est déjà sur la pile.
Essayez-le sur http://cjam.aditsu.net/
f.
Eh bien, il est devenu plus court encore! Après avoir écrit une solution pour un défi sans rapport , j'ai remarqué que le même truc pouvait être appliqué même ici. Alors on y va:
00000000 b4 08 cd 21 35 01 0a 86 c2 eb f7 |...!5......|
0000000b
Assemblée commentée:
org 100h
section .text
start:
mov ah,8 ; start with "read character with no echo"
lop:
; this loop runs twice per character read; first with ah=8,
; so "read character with no echo", then with ah=2, so
; "write character"; the switch is performed by the xor below
int 21h ; perform syscall
; ah is the syscall number; xor with 0x0a changes 8 to 2 and
; viceversa (so, switch read <=> write)
; al is the read character (when we did read); xor the low
; bit to change 0 to 1 and reverse
xor ax,0x0a01
mov dl,al ; put the read (and inverted character) in dl,
; where syscall 2 looks for the character to print
jmp lop ; loop
Je pense que ça ne devient pas beaucoup plus court que ça.En fait, ça l'a fait! Merci à @ninjalj pour avoir supprimé un octet de plus.
00000000 b4 08 cd 21 34 01 92 b4 02 cd 21 eb f3 |...!4.....!..|
0000000d
Cette version propose une interactivité avancée ™ - après son exécution à partir de la ligne de commande, elle crache les caractères "inversés" tant que vous écrivez les chiffres saisis (qui ne sont pas répercutés). pour sortir, faites juste un Ctrl-C.
Contrairement à la solution précédente, cela ne fonctionne pas correctement dans DosBox. DosBox ne prenant pas correctement en charge la combinaison de touches Ctrl-C , vous êtes obligé de fermer la fenêtre DosBox si vous souhaitez quitter. Dans une machine virtuelle avec DOS 6.0, il s'exécute comme prévu.
Source NASM:
org 100h
section .text
start:
mov ah,8
int 21h
xor al,1
xchg dx,ax
mov ah,2
int 21h
jmp start
Cela acceptait sa saisie depuis la ligne de commande; fonctionne correctement en tant que fichier .COM dans DosBox.
00000000 bb 01 00 b4 02 8a 97 81 00 80 f2 01 cd 21 43 3a |.............!C:|
00000010 1e 80 00 7c f0 c3 |...|..|
Entrée NASM:
org 100h
section .text
start:
mov bx, 1
mov ah, 2
loop:
mov dl, byte[bx+81h]
xor dl, 1
int 21h
inc bx
cmp bl, byte[80h]
jl loop
exit:
ret
xchg dx,axest 1 octet plus court quemov dl,al
tr 01 10
Prend l'entrée de STDIN.
Ou
y/01/10/
y 01 10
tr...
:~:!
Suppose que la chaîne d'origine est déjà sur la pile. Imprime la chaîne modifiée.
Essayez-le en ligne en collant le code suivant :
"10101110101010010100010001010110101001010":~:!
:~évalue chaque caractère de la chaîne, c'est-à-dire qu'il remplace le caractère 0 par l' entier 0.
:!calcule le NON logique de chaque entier. Cela transforme les 0 en 1 et les 1 en 0.
>,[>,]<[<]>[<+++++++[>-------<-]<+>>[++<]<[>]++++++++[>++++++<-]>.[-]>]
Explication:
>,[>,] Read characters until there are none left.
<[<] Return to start
>[< Loop as long as there are characters to invert
+++++++[>-------<-] Subtract 49 (ASCII value of 1)
>[++<] If not 0, add 2
+++[<++++>-]<[>>++++<<-]>> Add 48
. Print
[-] Set current cell to 0
>] Loop
apour 11.
Put this tasty pancake on top!
[]
Put this delicious pancake on top!
[#]
Put this pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
Put this supercalifragilisticexpialidociouseventhoughtheso pancake on top!
Flip the pancakes on top!
Take from the top pancakes!
Flip the pancakes on top!
Take from the top pancakes!
Put this supercalifragilisticexpialidociouseventhoughthes pancake on top!
Put the top pancakes together!
Show me a pancake!
If the pancake is tasty, go over to "".
Cela suppose que l’entrée se termine par un caractère nul. La stratégie est la suivante:
1de celle-ci.0(donnant un 1si nous avions 0, ou un 0si nous avions 1)0luii(char*s){*s^=*s?i(s+1),1:0;}
Essayez-le en ligne ici .
Merci d'avoir signalé l'astuce XOR, Dennis.
i(char*s){while(*s)*s++^=1;}
whileavec un forrésultat fixe d'une longueur de 28 caractères.
Oh, combien ce premier est nul. Assez moche, celui-ci est. 63 caractères.
print''.join([bin(~0)[3:] if x == '0' else bin(~1)[4:] for x in ''])Celui-ci est un peu mieux mais toujours pas aussi sophistiqué. 44 caractères.
print''.join([str(int(not(int(x)))) for x in ''])Depuis int(x) and 1renvoie int(x)si ce n'est pas 0 et sinon Faux. La solution peut encore être réduite à 36 caractères.
print''.join([str(1-int(x)) for x in ''])Depuis join()prend un générateur, les supports peuvent être supprimés. 32 caractères.
print''.join(str(1-int(x))for x in'')Et les backticks peuvent être utilisés à la place de str()
print''.join(`1-int(x)`for x in'')Réduit à 44 contre 34 grâce aux indications de @TheRare
Trouver son complément est difficile en python puisque bin(-int)renvoie -0bxxx d’où ce qui précède.
(int(x) and 1) == int(x)
'' == Falseet'hi' == True
''.join(`1-int(x)`for x in'')
repr(x)pour x <maxint est égal àstr(x)
'y/10/01/'
Le 9ème caractère est le drapeau 'p'
Usage:
$ echo '10101001' | perl -pe 'y/10/01/'
y/10/01/mais un caractère plus court car il n'a pas besoin de drapeaux
alert(prompt().replace(/./g,x=>x^1))s, il s.replace(/./g,x=>x^1)y a 22 caractères.
p=prompt(p().replace(/./g,x=>x^1))
(p=prompt)(p().replace(/./g,x=>x^1))et c'est la même longueur.
(Le labyrinthe est plus récent que ce défi, donc cette réponse n'est pas concurrente - ce n'est pas qu'elle gagne de toute façon ...)
1,
.$@
Ce code suppose que STDIN ne contient que les chiffres (en particulier, pas de nouvelle ligne).
Le pointeur d'instruction (IP) commence dans le coin supérieur gauche en allant à droite. Alors qu'il y a des chiffres à lire, il parcourt en boucle étroite le bloc 2x2 de gauche: 1appuyez sur un 1, ,lisez un chiffre, $XOR avec 1 pour alterner le dernier bit, .imprimez le résultat. L'IP prend cette boucle parce que le haut de la pile est positif après le XOR, de sorte qu'il tourne à droite. Quand nous touchons EOF, ,retourne à la -1place. Ensuite, le XOR va céder -2et avec cette valeur négative l’IP tourne à gauche @et le programme se termine.
Cette solution devrait être optimale pour Labyrinth: vous avez besoin ,et .pour une boucle d'E / S et @pour terminer le programme. Vous avez besoin d'au moins deux caractères (ici 1et $) pour basculer le dernier bit. Et vous avez besoin d'au moins une nouvelle ligne pour une boucle pouvant être terminée.
Sauf si ... si nous ignorons STDERR, c'est-à-dire, si nous terminons par une erreur, nous pouvons enregistrer le fichier @et nous n'avons également besoin d'aucun moyen de basculer entre deux chemins. Nous continuons simplement à lire et à imprimer jusqu'à ce que nous essayions accidentellement d'imprimer une valeur négative (la -2). Cela permet au moins deux solutions de 5 octets:
1,
.$
,_1$.
Utilisation de la syntaxe de table de règles requise par ce simulateur de MT en ligne. Emprunté à un article que j'ai publié il y a quelques mois sur mon blog d'utilisateur Googology Wiki.
0 0 1 r *
0 1 0 r *
0 _ _ * halt
Vous pouvez également tester cela en utilisant cette implémentation Java.
print''.join(`1-int(x)`for x in raw_input())Pourquoi le rendre complexe, ou utiliser des variables tricheuses?
print''.join('1-int(x)'for x in'input()'). Je ne pouvais pas obtenir les backticks dans le code de commentaire, donc les substitué par '.
`a\`b`-> a`b.
chartr("01","10",scan(,""))
Usage:
> chartr("01","10",scan(,""))
1: 10101110101010010100010001010110101001010
2:
Read 1 item
[1] "01010001010101101011101110101001010110101"
Programme complet. Invite stdin.
∊⍕¨~⍎¨⍞⍞ invite stdin
⍎¨ exécuter chaque personnage
~ pas logique
⍕¨ formater chaque caractère en texte
∊ ε nlist (aplatir)
<kbd>balise.
Il s'agit d'une fonction qui prend une chaîne binaire (de bout en bout Ans) en entrée et renvoie la sortie sous forme de chaîne inversée (non inversée), comme spécifié. Pour plus d’aide, vous pouvez consulter l’application de liste not(sur le wiki TI-BASIC. J'utilise la version compilée car elle est plus petite:
»*r>Õ¸r
En hex:
BB 2A 72 3E D5 B8 72
Explication
»*r - Prendre la fonction entrée sous forme de chaîne et convertir en liste
> - Pipe liste donnée aux opérateurs suivants
Õ¸r - Retourne l'inverse de la liste
»*r>Õ¸r ?
expr(Ans:Returnnot(Ans: 2. {Etant donné que la chaîne n'est pas séparée par des virgules et qu'elle ne commence pas par un , elle sera évaluée en un entier tel que 1000010011 et non en une liste. 3. Returnne fonctionne pas comme vous l'avez écrit; 4. Cela donne la sortie sous forme de liste, pas de chaîne.
map(\c->"10"!!read[c])
J'ai été surpris par le manque de solutions Haskell à ce défi, alors en voici une. Il est évalué à une fonction qui prend une chaîne et renvoie son inverse.
Rien d'extraordinaire ici.
map(\c-> ) -- For each character c in the input string:
[c] -- wrap c into a string,
read -- convert to integer,
"10"!! -- and index the string "10" with it.
0>~1+:#v_$>:#,_@
^ -1<
En supposant que la pile vide et EOF lisent -1.
0 pousse un \ 0 en tant que terminateur nul
>~1+:#v_ est une boucle d’entrée, lit ascii, ajoute 1, vérifie si EOF + 1 = 0,
^ -1< sinon, soustrait 1 et laisse la valeur ascii poussée sur la pile.
$>:#,_@ dépose la copie supplémentaire de zéro en haut de la pile, puis imprime la chaîne binaire de haut en bas
Si la pile vide lit 0, sauvegardez 2 octets avec
>~:1+#v_$>:#,_@
^ -1<
Une version d'environ 15 octets est possible en utilisant le même algorithme si EOF = 0, mais je ne dispose pas d'une telle implémentation pour tester.
'a#@~-,
Pour chaque caractère, cdans l'entrée, il imprime le caractère avec une valeur ascii de 94 - c, où 94 est la valeur de '0' + '1' ou 'a'
Methinks Python n’est pas le meilleur langage pour cela. :)
for i in input():print(1-int(i),end='')
Si vous souhaitez avoir une nouvelle ligne après la sortie, voici une alternative à 43 caractères:
print(''.join("01"[i<"1"]for i in input()))
end=''juste ,fera :) - à moins que vous souciez d'être là sans espace
printfonction de Python3 nécessite de modifier le endparamètre pour supprimer une nouvelle ligne à la fin de chaque impression. De plus, selon les spécifications de OP, je pense que je tiens à l'absence d'espaces. :) Merci pour le commentaire, cependant!
Les valeurs booléennes en J sont représentées par les nombres entiers 0et 1, qui sont bien sûr aussi des indices valides dans les tableaux (dans ce cas, le tableau à 2 caractères '01')
'01'{~'0'&=
Un peu tard pour la fête, mais voici le mien. :)
using System;class R{static void Main(string[]a){foreach(var v in a[0].ToCharArray()){Console.Write(int.Parse(v.ToString())^1);}}}
@(x)[97-x '']
Après avoir exécuté ce qui précède, appelez simplement la fonction avec votre chaîne d’entrée pour obtenir la chaîne inversée. Par exemple en cours d'exécution:
ans('10101110101010010100010001010110101001010')
impressions:
01010001010101101011101110101001010110101
Non compétitif car la langue postdate la question.
Iv2 0 12
>e>S SS
e1e0
^< <P
Avec en surbrillance:
