kimitoboku

#! /bin/bash

for i in {0..100}
do
  cat /dev/urandom | base64 | fold -w 20 | head -n 1 >> download_key
done

kimitoboku

(defun parse (functions data)
  (cond ((and (consp functions) (funcall (car functions) (cdr functions) data) ))
        ((eq functions data) 't)
        ('t 'nil)))

(defun terminal-symbol (list rest data)
  (cond ((and (consp data) (member (car data) list))
         (parse rest (cdr data)))
        ('t 'nil)))

kimitoboku

(defun my-match (pattern data)
  (cond ((and (consp pattern) (eq '* (car pattern)))
         (or (my-match (cdr pattern) data)
             (and (consp data)(my-match pattern (cdr data)))))
        ((and (consp pattern) (consp data) (eq (car pattern) (car data)))
         (my-match (cdr pattern) (cdr data)))
        ((eq pattern data) 't)
        ('t nil)))

(defun sample2 (pattern data)

kimitoboku

module Prompts;

extern (C) {
  char *getpass(const char *);
}


import std.stdio;
import std.string;
import std.conv;

kimitoboku

Web班勉強会課題解答

課題1 pingを作る

#! /bin/python

import sys
from scapy.all import *

kimitoboku

#! /bin/sh

sudo iptables -F
sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT
sudo /etc/init.d/apache2 restart
sudo sysctl -w vm.drop_caches=3

vmstat 1 700 > status.log &

kimitoboku

#! /bin/sh

sudo tail -f /var/log/apache2/p3/access.log  | awk '{
d = sprintf("%s-%s",$1,$4)
if($1 ~ /::1/)
{

}else if(list[$1]=="done"){

}else if(!(d in data)){

kimitoboku

#include<iostream>
#include<iomanip>

int main(int argc, char *argv[]){
  int n;
  double input;
  std::cout << "n次元の連立方程式:";
  std::cin >> n;
  double a[n][n];
  double e[n][n];

kimitoboku

#include<iostream>
#include<iomanip>

int main(int argc, char *argv[]){
  int n;
  double input;
  std::cout << "n次の正方行列? n:";
  std::cin >> n;
  double a[n][n];
  for(int i=0;i<n;i++){

kimitoboku

#include<iostream>
#include<iomanip>

int main(int argc, char *argv[]){
  int n;
  double input;
  std::cout << "n次の正方行列? n:";
  std::cin >> n;
  double a[n][n];
  double e[n][n];