help-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [SOLVED] (was: how to randomize (scample) regions in a an (org) buff


From: Emanuel Berg
Subject: Re: [SOLVED] (was: how to randomize (scample) regions in a an (org) buffer)
Date: Wed, 06 Oct 2021 21:59:24 +0200
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/29.0.50 (gnu/linux)

Uwe Brauer wrote:

> Actually it was quite easy as in 
>
> (defun randomise-region ()
>   "Like `ap/replace-words-randomly', but only replace inside region if it is 
> active.
> If the region is not active, replace from point to the end of the
> buffer.  The region is never considered active outside
> `transient-mark-mode'. "
>   (interactive)
>   (if (or (and (boundp 'zmacs-region-active-p) zmacs-region-active-p)
>         (and (boundp 'transient-mark-mode) transient-mark-mode mark-active))
>       (save-restriction
>         (save-excursion
>           (narrow-to-region (point) (mark))
>           (goto-char (point-min))
>           (ap/replace-words-randomly)))
>     (ap/replace-words-randomly)))

;;; -*- lexical-binding: t -*-
;;;
;;; this file:
;;;   http://user.it.uu.se/~embe8573/emacs-init/sort-incal.el
;;;   https://dataswamp.org/~incal/emacs-init/sort-incal.el

(require 'edit)
(require 'erc)
(require 'sort)

(setq sort-fold-case t)

(defun sort-second-field (beg end)
  (interactive "r")
  (sort-fields 2 beg end) )
(defalias 's2f #'sort-second-field)

(defun sort-lines-length (beg end)
  (interactive (if (use-region-p)
                   (list (region-beginning) (region-end))
                 (list (point-min) (point-max)) ))
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (sort-subr nil
                 #'forward-line
                 #'end-of-line
                 nil nil
                 (lambda (a b) (> (- (cdr a) (car a))
                                  (- (cdr b) (car b)) ))))))
(defalias 'sll #'sort-lines-length)

(defun sort-lines-random (beg end)
  (interactive "r")
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (sort-subr nil
                 #'forward-line
                 #'end-of-line
                 nil nil
                 (lambda (_ __) (zerop (random 2)) )))))
(defalias 'r #'sort-lines-random)

;; test here:
;; aaa
;; ccc
;; bbb
;; ddd

(defun sort-buffer-random ()
  (interactive)
  (sort-lines-random (point-min) (point-max))
  (save-buffer) )

(defun sort-whole-lines (beg end)
  (interactive "r")
  (save-excursion
    (let ((s (progn (goto-char beg) (line-beginning-position)))
          (e (progn (goto-char end) (line-end-position))) )
      (sort-lines nil s e) )))

(defun sort-buffer-and-save ()
  (interactive)
  (sort-lines nil (point-min) (point-max))
  (save-buffer) )
(defalias 'bs #'sort-buffer-and-save)

(defun insert-string-list (string-list)
  (when string-list
    (insert (format "%s" (car string-list)))
    (dolist (s (cdr string-list))
      (insert (format " %s" s)))))

(defun sort-line-words (beg end &optional set-delim)
  (interactive "r\nP")
  (let*((str       (region-to-string))
        (delim-str (when set-delim
                     (read-string "delimiter: ") ))
        (str-list  (split-string str delim-str))
        (sorted    (erc-sort-strings str-list)) )
    (kill-region beg end)
    (if set-delim
        (progn
          (dolist (s (nreverse (cdr (nreverse sorted))))
            (insert (format "%s%s" s delim-str)))
          (insert (format "%s" (car (last sorted)))))
      (insert-string-list sorted) )))
;;; sort me: a is just string test this
;;; sorted:  a is just string test this
;;;
;;; and me with a dash delim: this-is-just-a-test-string

(defun scramble (beg end)
  "Shuffle chars in region from BEG to END."
  (interactive "r")
  (when (use-region-p)
    (save-excursion
      (let*((str        (region-to-string))
            (chars      (delete "" (split-string str "")))
            (rand-chars (sort chars (lambda (_ __) (zerop (random 2))))) )
        (delete-region beg end)
        (dolist (c rand-chars)
          (insert c) )))))

(require 'seq)
(defun scramble-string (str)
  "Randomize the characters of a string."
  (interactive "sscramble me: ")
  (let ((rand-str (seq-sort (lambda (_ __) (zerop (random 2))) str )))
    (if (called-interactively-p 'any)
        (message rand-str)
      rand-str) ))

(defun comic-book-insult ()
  (interactive)
  (insert (concat (scramble-string "@#$%&") "!")) )

;; (comic-book-insult) ; @#$%&!
;; (comic-book-insult) ; $&#@%!

;; (scramble-string "Hello there, Emacs is very cool piece of software")
;; "aye eposrr lvre olsec,ewfico ceti ftomH hseoa l E"

(provide 'sort-incal)

-- 
underground experts united
https://dataswamp.org/~incal




reply via email to

[Prev in Thread] Current Thread [Next in Thread]